src/lib/hints.cc

   1 /*
   2     Copyright (C) 2016-2021 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 #include "dcp_content_type.h"
  22 #include "hints.h"
  23 #include "types.h"
  24 #include "film.h"
  25 #include "content.h"
  26 #include "video_content.h"
  27 #include "text_content.h"
  28 #include "audio_processor.h"
  29 #include "font.h"
  30 #include "font_data.h"
  31 #include "ratio.h"
  32 #include "audio_analysis.h"
  33 #include "compose.hpp"
  34 #include "util.h"
  35 #include "cross.h"
  36 #include "player.h"
  37 #include "writer.h"
  38 #include <dcp/cpl.h>
  39 #include <dcp/raw_convert.h>
  40 #include <dcp/reel.h>
  41 #include <dcp/reel_closed_caption_asset.h>
  42 #include <dcp/reel_subtitle_asset.h>
  43 #include <boost/algorithm/string.hpp>
  44 #include <iostream>
  45
  46 #include "i18n.h"
  47
  48 using std::cout;
  49 using std::make_shared;
  50 using std::max;
  51 using std::min;
  52 using std::pair;
  53 using std::shared_ptr;
  54 using std::string;
  55 using std::vector;
  56 using std::weak_ptr;
  57 using boost::optional;
  58 using boost::bind;
  59 using namespace dcpomatic;
  60 #if BOOST_VERSION >= 106100
  61 using namespace boost::placeholders;
  62 #endif
  63
  64
  65 /* When checking to see if things are too big, we'll say they are if they
  66  * are more than the target size minus this "slack."
  67  */
  68 #define SIZE_SLACK 4096
  69
  70
  71 /* When writing hints:
  72  * - put quotation marks around the name of a GUI tab that you are referring to (e.g. "DCP" or "DCP→Video" tab)
  73  */
  74
  75
  76 Hints::Hints (weak_ptr<const Film> film)
  77         : WeakConstFilm (film)
  78         , _writer (new Writer(film, weak_ptr<Job>(), true))
  79         , _stop (false)
  80 {
  81
  82 }
  83
  84 void
  85 Hints::start ()
  86 {
  87         _thread = boost::thread (bind(&Hints::thread, this));
  88 }
  89
  90 Hints::~Hints ()
  91 {
  92         boost::this_thread::disable_interruption dis;
  93
  94         try {
  95                 _stop = true;
  96                 _thread.interrupt ();
  97                 _thread.join ();
  98         } catch (...) {}
  99 }
 100
 101
 102 void
 103 Hints::check_few_audio_channels ()
 104 {
 105         if (film()->audio_channels() < 6) {
 106                 hint (_("Your DCP has fewer than 6 audio channels.  This may cause problems on some projectors.  You may want to set the DCP to have 6 channels.  It does not matter if your content has fewer channels, as DCP-o-matic will fill the extras with silence."));
 107         }
 108 }
 109
 110
 111 void
 112 Hints::check_upmixers ()
 113 {
 114         auto ap = film()->audio_processor();
 115         if (ap && (ap->id() == "stereo-5.1-upmix-a" || ap->id() == "stereo-5.1-upmix-b")) {
 116                 hint (_("You are using DCP-o-matic's stereo-to-5.1 upmixer.  This is experimental and may result in poor-quality audio.  If you continue, you should listen to the resulting DCP in a cinema to make sure that it sounds good."));
 117         }
 118 }
 119
 120
 121 void
 122 Hints::check_incorrect_container ()
 123 {
 124         int narrower_than_scope = 0;
 125         int scope = 0;
 126         for (auto i: film()->content()) {
 127                 if (i->video) {
 128                         Ratio const * r = Ratio::nearest_from_ratio(i->video->scaled_size(film()->frame_size()).ratio());
 129                         if (r && r->id() == "239") {
 130                                 ++scope;
 131                         } else if (r && r->id() != "239" && r->id() != "235" && r->id() != "190") {
 132                                 ++narrower_than_scope;
 133                         }
 134                 }
 135         }
 136
 137         string const film_container = film()->container()->id();
 138
 139         if (scope && !narrower_than_scope && film_container == "185") {
 140                 hint (_("All of your content is in Scope (2.39:1) but your DCP's container is Flat (1.85:1).  This will letter-box your content inside a Flat (1.85:1) frame.  You may prefer to set your DCP's container to Scope (2.39:1) in the \"DCP\" tab."));
 141         }
 142
 143         if (!scope && narrower_than_scope && film_container == "239") {
 144                 hint (_("All of your content narrower than 1.90:1 but your DCP's container is Scope (2.39:1).  This will pillar-box your content.  You may prefer to set your DCP's container to have the same ratio as your content."));
 145         }
 146 }
 147
 148
 149 void
 150 Hints::check_unusual_container ()
 151 {
 152         auto const film_container = film()->container()->id();
 153         if (film_container != "185" && film_container != "239") {
 154                 hint (_("Your DCP uses an unusual container ratio.  This may cause problems on some projectors.  If possible, use Flat or Scope for the DCP container ratio"));
 155         }
 156 }
 157
 158
 159 void
 160 Hints::check_high_j2k_bandwidth ()
 161 {
 162         if (film()->j2k_bandwidth() >= 245000000) {
 163                 hint (_("A few projectors have problems playing back very high bit-rate DCPs.  It is a good idea to drop the JPEG2000 bandwidth down to about 200Mbit/s; this is unlikely to have any visible effect on the image."));
 164         }
 165 }
 166
 167
 168 void
 169 Hints::check_frame_rate ()
 170 {
 171         auto f = film ();
 172         switch (f->video_frame_rate()) {
 173         case 24:
 174                 /* Fine */
 175                 break;
 176         case 25:
 177         {
 178                 /* You might want to go to 24 */
 179                 string base = String::compose(_("You are set up for a DCP at a frame rate of %1 fps.  This frame rate is not supported by all projectors.  You may want to consider changing your frame rate to %2 fps."), 25, 24);
 180                 if (f->interop()) {
 181                         base += "  ";
 182                         base += _("If you do use 25fps you should change your DCP standard to SMPTE.");
 183                 }
 184                 hint (base);
 185                 break;
 186         }
 187         case 30:
 188                 /* 30fps: we can't really offer any decent solutions */
 189                 hint (_("You are set up for a DCP frame rate of 30fps, which is not supported by all projectors.  Be aware that you may have compatibility problems."));
 190                 break;
 191         case 48:
 192         case 50:
 193         case 60:
 194                 /* You almost certainly want to go to half frame rate */
 195                 hint (String::compose(_("You are set up for a DCP at a frame rate of %1 fps.  This frame rate is not supported by all projectors.  You are advised to change the DCP frame rate to %2 fps."), f->video_frame_rate(), f->video_frame_rate() / 2));
 196                 break;
 197         }
 198 }
 199
 200
 201 void
 202 Hints::check_4k_3d ()
 203 {
 204         auto f = film();
 205         if (f->resolution() == Resolution::FOUR_K && f->three_d()) {
 206                 hint (_("4K 3D is only supported by a very limited number of projectors.  Unless you know that you will play this DCP back on a capable projector, it is advisable to set the DCP to be 2K in the \"DCP→Video\" tab."));
 207         }
 208 }
 209
 210
 211 void
 212 Hints::check_speed_up ()
 213 {
 214         optional<double> lowest_speed_up;
 215         optional<double> highest_speed_up;
 216         for (auto i: film()->content()) {
 217                 double spu = film()->active_frame_rate_change(i->position()).speed_up;
 218                 if (!lowest_speed_up || spu < *lowest_speed_up) {
 219                         lowest_speed_up = spu;
 220                 }
 221                 if (!highest_speed_up || spu > *highest_speed_up) {
 222                         highest_speed_up = spu;
 223                 }
 224         }
 225
 226         double worst_speed_up = 1;
 227         if (highest_speed_up) {
 228                 worst_speed_up = *highest_speed_up;
 229         }
 230         if (lowest_speed_up) {
 231                 worst_speed_up = max (worst_speed_up, 1 / *lowest_speed_up);
 232         }
 233
 234         if (worst_speed_up > 25.5/24.0) {
 235                 hint (_("There is a large difference between the frame rate of your DCP and that of some of your content.  This will cause your audio to play back at a much lower or higher pitch than it should.  You are advised to set your DCP frame rate to one closer to your content, provided that your target projection systems support your chosen DCP rate."));
 236         }
 237
 238 }
 239
 240
 241 void
 242 Hints::check_interop ()
 243 {
 244         if (film()->interop()) {
 245                 hint (_("In general it is now advisable to make SMPTE DCPs unless you have a particular reason to use Interop.  You are advised to set your DCP to use the SMPTE standard in the \"DCP\" tab."));
 246         }
 247 }
 248
 249
 250 void
 251 Hints::check_big_font_files ()
 252 {
 253         bool big_font_files = false;
 254         if (film()->interop ()) {
 255                 for (auto i: film()->content()) {
 256                         for (auto j: i->text) {
 257                                 for (auto k: j->fonts()) {
 258                                         optional<boost::filesystem::path> const p = k->file ();
 259                                         if (p && boost::filesystem::file_size(p.get()) >= (MAX_FONT_FILE_SIZE - SIZE_SLACK)) {
 260                                                 big_font_files = true;
 261                                         }
 262                                 }
 263                         }
 264                 }
 265         }
 266
 267         if (big_font_files) {
 268                 hint (_("You have specified a font file which is larger than 640kB.  This is very likely to cause problems on playback."));
 269         }
 270 }
 271
 272
 273 void
 274 Hints::check_vob ()
 275 {
 276         int vob = 0;
 277         for (auto i: film()->content()) {
 278                 if (boost::algorithm::starts_with (i->path(0).filename().string(), "VTS_")) {
 279                         ++vob;
 280                 }
 281         }
 282
 283         if (vob > 1) {
 284                 hint (String::compose (_("You have %1 files that look like they are VOB files from DVD. You should join them to ensure smooth joins between the files."), vob));
 285         }
 286 }
 287
 288
 289 void
 290 Hints::check_3d_in_2d ()
 291 {
 292         int three_d = 0;
 293         for (auto i: film()->content()) {
 294                 if (i->video && i->video->frame_type() != VideoFrameType::TWO_D) {
 295                         ++three_d;
 296                 }
 297         }
 298
 299         if (three_d > 0 && !film()->three_d()) {
 300                 hint (_("You are using 3D content but your DCP is set to 2D.  Set the DCP to 3D if you want to play it back on a 3D system (e.g. Real-D, MasterImage etc.)"));
 301         }
 302 }
 303
 304
 305 void
 306 Hints::check_loudness ()
 307 {
 308         auto path = film()->audio_analysis_path(film()->playlist());
 309         if (boost::filesystem::exists (path)) {
 310                 try {
 311                         auto an = make_shared<AudioAnalysis>(path);
 312
 313                         string ch;
 314
 315                         auto sample_peak = an->sample_peak ();
 316                         auto true_peak = an->true_peak ();
 317
 318                         for (size_t i = 0; i < sample_peak.size(); ++i) {
 319                                 float const peak = max (sample_peak[i].peak, true_peak.empty() ? 0 : true_peak[i]);
 320                                 float const peak_dB = linear_to_db(peak) + an->gain_correction(film()->playlist());
 321                                 if (peak_dB > -3) {
 322                                         ch += dcp::raw_convert<string> (short_audio_channel_name (i)) + ", ";
 323                                 }
 324                         }
 325
 326                         ch = ch.substr (0, ch.length() - 2);
 327
 328                         if (!ch.empty ()) {
 329                                 hint (String::compose (
 330                                               _("Your audio level is very high (on %1).  You should reduce the gain of your audio content."),
 331                                               ch
 332                                               )
 333                                         );
 334                         }
 335                 } catch (OldFormatError& e) {
 336                         /* The audio analysis is too old to load in; just skip this hint as if
 337                            it had never been run.
 338                         */
 339                 }
 340         }
 341 }
 342
 343
 344 static
 345 bool
 346 subtitle_mxf_too_big (shared_ptr<dcp::SubtitleAsset> asset)
 347 {
 348         return asset && asset->file() && boost::filesystem::file_size(*asset->file()) >= (MAX_TEXT_MXF_SIZE - SIZE_SLACK);
 349 }
 350
 351
 352 void
 353 Hints::check_out_of_range_markers ()
 354 {
 355         auto const length = film()->length();
 356         for (auto const& i: film()->markers()) {
 357                 if (i.second >= length) {
 358                         hint (_("At least one marker comes after the end of the project and will be ignored."));
 359                 }
 360         }
 361 }
 362
 363
 364 void
 365 Hints::thread ()
 366 {
 367         auto film = _film.lock ();
 368         if (!film) {
 369                 return;
 370         }
 371
 372         auto content = film->content ();
 373
 374         check_interop ();
 375         check_big_font_files ();
 376         check_few_audio_channels ();
 377         check_upmixers ();
 378         check_incorrect_container ();
 379         check_unusual_container ();
 380         check_high_j2k_bandwidth ();
 381         check_frame_rate ();
 382         check_4k_3d ();
 383         check_speed_up ();
 384         check_vob ();
 385         check_3d_in_2d ();
 386         check_loudness ();
 387         check_ffec_and_ffmc_in_smpte_feature ();
 388         check_out_of_range_markers ();
 389         check_text_languages ();
 390
 391         emit (bind(boost::ref(Progress), _("Examining closed captions")));
 392
 393         auto player = make_shared<Player>(film);
 394         player->set_ignore_video ();
 395         player->set_ignore_audio ();
 396         player->Text.connect (bind(&Hints::text, this, _1, _2, _3, _4));
 397
 398         struct timeval last_pulse;
 399         gettimeofday (&last_pulse, 0);
 400
 401         try {
 402                 while (!player->pass()) {
 403
 404                         struct timeval now;
 405                         gettimeofday (&now, 0);
 406                         if ((seconds(now) - seconds(last_pulse)) > 1) {
 407                                 if (_stop) {
 408                                         break;
 409                                 }
 410                                 emit (bind (boost::ref(Pulse)));
 411                                 last_pulse = now;
 412                         }
 413                 }
 414         } catch (...) {
 415                 store_current ();
 416         }
 417
 418         _writer->write (player->get_subtitle_fonts());
 419
 420         bool ccap_xml_too_big = false;
 421         bool ccap_mxf_too_big = false;
 422         bool subs_mxf_too_big = false;
 423
 424         boost::filesystem::path dcp_dir = film->dir("hints") / dcpomatic::get_process_id();
 425         boost::filesystem::remove_all (dcp_dir);
 426
 427         try {
 428                 _writer->finish (film->dir("hints") / dcpomatic::get_process_id());
 429         } catch (...) {
 430                 store_current ();
 431                 emit (bind(boost::ref(Finished)));
 432                 return;
 433         }
 434
 435         dcp::DCP dcp (dcp_dir);
 436         dcp.read ();
 437         DCPOMATIC_ASSERT (dcp.cpls().size() == 1);
 438         for (auto reel: dcp.cpls()[0]->reels()) {
 439                 for (auto ccap: reel->closed_captions()) {
 440                         if (ccap->asset() && ccap->asset()->xml_as_string().length() > static_cast<size_t>(MAX_CLOSED_CAPTION_XML_SIZE - SIZE_SLACK) && !ccap_xml_too_big) {
 441                                 hint (_(
 442                                                 "At least one of your closed caption files' XML part is larger than " MAX_CLOSED_CAPTION_XML_SIZE_TEXT
 443                                                 ".  You should divide the DCP into shorter reels."
 444                                        ));
 445                                 ccap_xml_too_big = true;
 446                         }
 447                         if (subtitle_mxf_too_big(ccap->asset()) && !ccap_mxf_too_big) {
 448                                 hint (_(
 449                                                 "At least one of your closed caption files is larger than " MAX_TEXT_MXF_SIZE_TEXT
 450                                                 " in total.  You should divide the DCP into shorter reels."
 451                                        ));
 452                                 ccap_mxf_too_big = true;
 453                         }
 454                 }
 455                 if (reel->main_subtitle() && subtitle_mxf_too_big(reel->main_subtitle()->asset()) && !subs_mxf_too_big) {
 456                         hint (_(
 457                                         "At least one of your subtitle files is larger than " MAX_TEXT_MXF_SIZE_TEXT " in total.  "
 458                                         "You should divide the DCP into shorter reels."
 459                                ));
 460                         subs_mxf_too_big = true;
 461                 }
 462         }
 463         boost::filesystem::remove_all (dcp_dir);
 464
 465         emit (bind(boost::ref(Finished)));
 466 }
 467
 468 void
 469 Hints::hint (string h)
 470 {
 471         emit(bind(boost::ref(Hint), h));
 472 }
 473
 474 void
 475 Hints::text (PlayerText text, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period)
 476 {
 477         _writer->write (text, type, track, period);
 478
 479         switch (type) {
 480         case TextType::CLOSED_CAPTION:
 481                 closed_caption (text, period);
 482                 break;
 483         case TextType::OPEN_SUBTITLE:
 484                 open_subtitle (text, period);
 485                 break;
 486         default:
 487                 break;
 488         }
 489 }
 490
 491
 492 void
 493 Hints::closed_caption (PlayerText text, DCPTimePeriod period)
 494 {
 495         int lines = text.string.size();
 496         for (auto i: text.string) {
 497                 if (utf8_strlen(i.text()) > MAX_CLOSED_CAPTION_LENGTH) {
 498                         ++lines;
 499                         if (!_long_ccap) {
 500                                 _long_ccap = true;
 501                                 hint (
 502                                         String::compose(
 503                                                 "At least one of your closed caption lines has more than %1 characters.  "
 504                                                 "It is advisable to make each line %1 characters at most in length.",
 505                                                 MAX_CLOSED_CAPTION_LENGTH,
 506                                                 MAX_CLOSED_CAPTION_LENGTH)
 507                                      );
 508                         }
 509                 }
 510         }
 511
 512         if (!_too_many_ccap_lines && lines > MAX_CLOSED_CAPTION_LINES) {
 513                 hint (String::compose(_("Some of your closed captions span more than %1 lines, so they will be truncated."), MAX_CLOSED_CAPTION_LINES));
 514                 _too_many_ccap_lines = true;
 515         }
 516
 517         /* XXX: maybe overlapping closed captions (i.e. different languages) are OK with Interop? */
 518         if (film()->interop() && !_overlap_ccap && _last_ccap && _last_ccap->overlap(period)) {
 519                 _overlap_ccap = true;
 520                 hint (_("You have overlapping closed captions, which are not allowed in Interop DCPs.  Change your DCP standard to SMPTE."));
 521         }
 522
 523         _last_ccap = period;
 524 }
 525
 526
 527 void
 528 Hints::open_subtitle (PlayerText text, DCPTimePeriod period)
 529 {
 530         if (period.from < DCPTime::from_seconds(4) && !_early_subtitle) {
 531                 _early_subtitle = true;
 532                 hint (_("It is advisable to put your first subtitle at least 4 seconds after the start of the DCP to make sure it is seen."));
 533         }
 534
 535         int const vfr = film()->video_frame_rate ();
 536
 537         if (period.duration().frames_round(vfr) < 15 && !_short_subtitle) {
 538                 _short_subtitle = true;
 539                 hint (_("At least one of your subtitles lasts less than 15 frames.  It is advisable to make each subtitle at least 15 frames long."));
 540         }
 541
 542         if (_last_subtitle && DCPTime(period.from - _last_subtitle->to).frames_round(vfr) < 2 && !_subtitles_too_close) {
 543                 _subtitles_too_close = true;
 544                 hint (_("At least one of your subtitles starts less than 2 frames after the previous one.  It is advisable to make the gap between subtitles at least 2 frames."));
 545         }
 546
 547         if (text.string.size() > 3 && !_too_many_subtitle_lines) {
 548                 _too_many_subtitle_lines = true;
 549                 hint (_("At least one of your subtitles has more than 3 lines.  It is advisable to use no more than 3 lines."));
 550         }
 551
 552         size_t longest_line = 0;
 553         for (auto const& i: text.string) {
 554                 longest_line = max (longest_line, i.text().length());
 555         }
 556
 557         if (longest_line > 52 && !_long_subtitle) {
 558                 _long_subtitle = true;
 559                 hint (_("At least one of your subtitle lines has more than 52 characters.  It is recommended to make each line 52 characters at most in length."));
 560         }
 561
 562         if (longest_line > 79 && !_very_long_subtitle) {
 563                 _very_long_subtitle = true;
 564                 hint (_("At least one of your subtitle lines has more than 79 characters.  You should make each line 79 characters at most in length."));
 565         }
 566
 567         _last_subtitle = period;
 568 }
 569
 570
 571 void
 572 Hints::check_ffec_and_ffmc_in_smpte_feature ()
 573 {
 574         auto f = film();
 575         if (!f->interop() && f->dcp_content_type()->libdcp_kind() == dcp::ContentKind::FEATURE && (!f->marker(dcp::Marker::FFEC) || !f->marker(dcp::Marker::FFMC))) {
 576                 hint (_("SMPTE DCPs with the type FTR (feature) should have markers for the first frame of end credits (FFEC) and the first frame of moving credits (FFMC).  You should add these markers using the 'Markers' button in the \"DCP\" tab."));
 577         }
 578 }
 579
 580
 581 void
 582 Hints::join ()
 583 {
 584         _thread.join ();
 585 }
 586
 587
 588 void
 589 Hints::check_text_languages ()
 590 {
 591         for (auto i: film()->content()) {
 592                 for (auto j: i->text) {
 593                         if (j->use() && !j->language()) {
 594                                 hint (_("At least one piece of subtitle or closed caption content has no specified language.  "
 595                                         "It is advisable to set the language for each piece of subtitle or closed caption content "
 596                                         "in the \"Content→Timed text\", \"Content→Open subtitles\" or \"Content→Closed captions\" tab"));
 597                                 return;
 598                         }
 599                 }
 600         }
 601 }