test/ffmpeg_encoder_test.cc

   1 /*
   2     Copyright (C) 2017-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
  22 #include "lib/audio_content.h"
  23 #include "lib/compose.hpp"
  24 #include "lib/config.h"
  25 #include "lib/constants.h"
  26 #include "lib/content_factory.h"
  27 #include "lib/cross.h"
  28 #include "lib/dcp_content.h"
  29 #include "lib/dcpomatic_log.h"
  30 #include "lib/ffmpeg_content.h"
  31 #include "lib/ffmpeg_encoder.h"
  32 #include "lib/ffmpeg_examiner.h"
  33 #include "lib/film.h"
  34 #include "lib/image_content.h"
  35 #include "lib/ratio.h"
  36 #include "lib/string_text_file_content.h"
  37 #include "lib/text_content.h"
  38 #include "lib/transcode_job.h"
  39 #include "lib/video_content.h"
  40 #include "test.h"
  41 #include <dcp/file.h>
  42 #include <dcp/raw_convert.h>
  43 #include <boost/test/unit_test.hpp>
  44
  45
  46 using std::make_shared;
  47 using std::string;
  48 using std::vector;
  49 using namespace dcpomatic;
  50
  51
  52 static void
  53 ffmpeg_content_test (int number, boost::filesystem::path content, ExportFormat format)
  54 {
  55         Cleanup cl;
  56
  57         string name = "ffmpeg_encoder_";
  58         string extension;
  59         switch (format) {
  60         case ExportFormat::H264_AAC:
  61                 name += "h264";
  62                 extension = "mp4";
  63                 break;
  64         case ExportFormat::PRORES_4444:
  65                 name += "prores-444";
  66                 extension = "mov";
  67                 break;
  68         case ExportFormat::PRORES_HQ:
  69                 name += "prores-hq";
  70                 extension = "mov";
  71                 break;
  72         case ExportFormat::SUBTITLES_DCP:
  73                 BOOST_REQUIRE (false);
  74         }
  75
  76         name = String::compose("%1_test%2", name, number);
  77
  78         auto c = make_shared<FFmpegContent>(content);
  79         auto film = new_test_film2 (name, {c}, &cl);
  80         film->set_name (name);
  81         film->set_audio_channels (6);
  82
  83         film->write_metadata ();
  84         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
  85         auto file = boost::filesystem::path("build") / "test" / String::compose("%1.%2", name, extension);
  86         cl.add (file);
  87         FFmpegEncoder encoder (film, job, file, format, false, false, false, 23);
  88         encoder.go ();
  89
  90         cl.run ();
  91 }
  92
  93
  94 /** Red / green / blue MP4 -> Prores */
  95 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test1)
  96 {
  97         ffmpeg_content_test (1, "test/data/test.mp4", ExportFormat::PRORES_HQ);
  98 }
  99
 100
 101 /** Dolby Aurora trailer VOB -> Prores */
 102 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test2)
 103 {
 104         ffmpeg_content_test (2, TestPaths::private_data() / "dolby_aurora.vob", ExportFormat::PRORES_HQ);
 105 }
 106
 107
 108 /** Sintel trailer -> Prores */
 109 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test3)
 110 {
 111         ffmpeg_content_test (3, TestPaths::private_data() / "Sintel_Trailer1.480p.DivX_Plus_HD.mkv", ExportFormat::PRORES_HQ);
 112 }
 113
 114
 115 /** Big Buck Bunny trailer -> Prores */
 116 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test4)
 117 {
 118         ffmpeg_content_test (4, TestPaths::private_data() / "big_buck_bunny_trailer_480p.mov", ExportFormat::PRORES_HQ);
 119 }
 120
 121
 122 /** Still image -> Prores */
 123 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test5)
 124 {
 125         auto film = new_test_film ("ffmpeg_encoder_prores_test5");
 126         film->set_name ("ffmpeg_encoder_prores_test5");
 127         auto c = make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png");
 128         film->set_container (Ratio::from_id ("185"));
 129         film->set_audio_channels (6);
 130
 131         film->examine_and_add_content (c);
 132         BOOST_REQUIRE (!wait_for_jobs ());
 133
 134         c->video->set_length (240);
 135
 136         film->write_metadata ();
 137         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 138         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_test5.mov", ExportFormat::PRORES_HQ, false, false, false, 23);
 139         encoder.go ();
 140 }
 141
 142
 143 /** Subs -> Prores */
 144 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test6)
 145 {
 146         auto film = new_test_film ("ffmpeg_encoder_prores_test6");
 147         film->set_name ("ffmpeg_encoder_prores_test6");
 148         film->set_container (Ratio::from_id ("185"));
 149         film->set_audio_channels (6);
 150
 151         auto s = make_shared<StringTextFileContent>("test/data/subrip2.srt");
 152         film->examine_and_add_content (s);
 153         BOOST_REQUIRE (!wait_for_jobs ());
 154         s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 155         s->only_text()->set_effect (dcp::Effect::SHADOW);
 156         s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
 157         film->write_metadata();
 158
 159         auto job = make_shared<TranscodeJob> (film, TranscodeJob::ChangedBehaviour::IGNORE);
 160         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_test6.mov", ExportFormat::PRORES_HQ, false, false, false, 23);
 161         encoder.go ();
 162 }
 163
 164
 165 /** Video + subs -> Prores */
 166 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_test7)
 167 {
 168         auto film = new_test_film ("ffmpeg_encoder_prores_test7");
 169         film->set_name ("ffmpeg_encoder_prores_test7");
 170         film->set_container (Ratio::from_id ("185"));
 171         film->set_audio_channels (6);
 172
 173         auto c = make_shared<FFmpegContent>("test/data/test.mp4");
 174         film->examine_and_add_content (c);
 175         BOOST_REQUIRE (!wait_for_jobs ());
 176
 177         auto s = make_shared<StringTextFileContent>("test/data/subrip.srt");
 178         film->examine_and_add_content (s);
 179         BOOST_REQUIRE (!wait_for_jobs ());
 180         s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 181         s->only_text()->set_effect (dcp::Effect::SHADOW);
 182         s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
 183
 184         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 185         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_test7.mov", ExportFormat::PRORES_HQ, false, false, false, 23);
 186         encoder.go ();
 187 }
 188
 189
 190 /** Red / green / blue MP4 -> H264 */
 191 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test1)
 192 {
 193         ffmpeg_content_test(1, "test/data/test.mp4", ExportFormat::H264_AAC);
 194 }
 195
 196
 197 /** Just subtitles -> H264 */
 198 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test2)
 199 {
 200         auto film = new_test_film ("ffmpeg_encoder_h264_test2");
 201         film->set_name ("ffmpeg_encoder_h264_test2");
 202         film->set_container (Ratio::from_id ("185"));
 203         film->set_audio_channels (6);
 204
 205         auto s = make_shared<StringTextFileContent>("test/data/subrip2.srt");
 206         film->examine_and_add_content (s);
 207         BOOST_REQUIRE (!wait_for_jobs ());
 208         s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 209         s->only_text()->set_effect (dcp::Effect::SHADOW);
 210         s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
 211         film->write_metadata();
 212
 213         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 214         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_h264_test2.mp4", ExportFormat::H264_AAC, false, false, false, 23);
 215         encoder.go ();
 216 }
 217
 218
 219 /** Video + subs -> H264 */
 220 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test3)
 221 {
 222         auto film = new_test_film ("ffmpeg_encoder_h264_test3");
 223         film->set_name ("ffmpeg_encoder_h264_test3");
 224         film->set_container (Ratio::from_id ("185"));
 225         film->set_audio_channels (6);
 226
 227         auto c = make_shared<FFmpegContent>("test/data/test.mp4");
 228         film->examine_and_add_content (c);
 229         BOOST_REQUIRE (!wait_for_jobs());
 230
 231         auto s = make_shared<StringTextFileContent>("test/data/subrip.srt");
 232         film->examine_and_add_content (s);
 233         BOOST_REQUIRE (!wait_for_jobs ());
 234         s->only_text()->set_colour (dcp::Colour (255, 255, 0));
 235         s->only_text()->set_effect (dcp::Effect::SHADOW);
 236         s->only_text()->set_effect_colour (dcp::Colour (0, 255, 255));
 237         film->write_metadata();
 238
 239         auto job = make_shared<TranscodeJob> (film, TranscodeJob::ChangedBehaviour::IGNORE);
 240         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_h264_test3.mp4", ExportFormat::H264_AAC, false, false, false, 23);
 241         encoder.go ();
 242 }
 243
 244
 245 /** Scope-in-flat DCP -> H264 */
 246 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test4)
 247 {
 248         auto film = new_test_film2("ffmpeg_encoder_h264_test4", {make_shared<DCPContent>("test/data/scope_dcp")});
 249         BOOST_REQUIRE(!wait_for_jobs());
 250
 251         film->set_container(Ratio::from_id("185"));
 252
 253         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 254         FFmpegEncoder encoder(film, job, "build/test/ffmpeg_encoder_h264_test4.mp4", ExportFormat::H264_AAC, false, false, false, 23);
 255         encoder.go();
 256 }
 257
 258
 259 /** Test mixdown from 5.1 to stereo */
 260 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test5)
 261 {
 262         auto film = new_test_film ("ffmpeg_transcoder_h264_test5");
 263         film->set_name ("ffmpeg_transcoder_h264_test5");
 264         film->set_container (Ratio::from_id ("185"));
 265         film->set_audio_channels (6);
 266
 267         auto L = make_shared<FFmpegContent>("test/data/L.wav");
 268         film->examine_and_add_content (L);
 269         auto R = make_shared<FFmpegContent>("test/data/R.wav");
 270         film->examine_and_add_content (R);
 271         auto C = make_shared<FFmpegContent>("test/data/C.wav");
 272         film->examine_and_add_content (C);
 273         auto Ls = make_shared<FFmpegContent>("test/data/Ls.wav");
 274         film->examine_and_add_content (Ls);
 275         auto Rs = make_shared<FFmpegContent>("test/data/Rs.wav");
 276         film->examine_and_add_content (Rs);
 277         auto Lfe = make_shared<FFmpegContent>("test/data/Lfe.wav");
 278         film->examine_and_add_content (Lfe);
 279         BOOST_REQUIRE (!wait_for_jobs ());
 280
 281         AudioMapping map (1, MAX_DCP_AUDIO_CHANNELS);
 282
 283         L->set_position (film, DCPTime::from_seconds(0));
 284         map.make_zero ();
 285         map.set (0, 0, 1);
 286         L->audio->set_mapping (map);
 287         R->set_position (film, DCPTime::from_seconds(1));
 288         map.make_zero ();
 289         map.set (0, 1, 1);
 290         R->audio->set_mapping (map);
 291         C->set_position (film, DCPTime::from_seconds(2));
 292         map.make_zero ();
 293         map.set (0, 2, 1);
 294         C->audio->set_mapping (map);
 295         Lfe->set_position (film, DCPTime::from_seconds(3));
 296         map.make_zero ();
 297         map.set (0, 3, 1);
 298         Lfe->audio->set_mapping (map);
 299         Ls->set_position (film, DCPTime::from_seconds(4));
 300         map.make_zero ();
 301         map.set (0, 4, 1);
 302         Ls->audio->set_mapping (map);
 303         Rs->set_position (film, DCPTime::from_seconds(5));
 304         map.make_zero ();
 305         map.set (0, 5, 1);
 306         Rs->audio->set_mapping (map);
 307
 308         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 309         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_h264_test5.mp4", ExportFormat::H264_AAC, true, false, false, 23);
 310         encoder.go ();
 311
 312         check_ffmpeg ("build/test/ffmpeg_encoder_h264_test5.mp4", "test/data/ffmpeg_encoder_h264_test5.mp4", 1);
 313 }
 314
 315
 316 /** Test export of a VF */
 317 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test6)
 318 {
 319         auto film = new_test_film2 ("ffmpeg_encoder_h264_test6_ov");
 320         film->examine_and_add_content (make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png"));
 321         BOOST_REQUIRE (!wait_for_jobs());
 322         make_and_verify_dcp (film);
 323
 324         auto film2 = new_test_film2 ("ffmpeg_encoder_h264_test6_vf");
 325         auto ov = make_shared<DCPContent>("build/test/ffmpeg_encoder_h264_test6_ov/" + film->dcp_name(false));
 326         film2->examine_and_add_content (ov);
 327         BOOST_REQUIRE (!wait_for_jobs());
 328         ov->set_reference_video (true);
 329         auto subs = content_factory("test/data/subrip.srt")[0];
 330         film2->examine_and_add_content (subs);
 331         BOOST_REQUIRE (!wait_for_jobs());
 332         for (auto i: subs->text) {
 333                 i->set_use (true);
 334         }
 335
 336         auto job = make_shared<TranscodeJob>(film2, TranscodeJob::ChangedBehaviour::IGNORE);
 337         FFmpegEncoder encoder (film2, job, "build/test/ffmpeg_encoder_h264_test6_vf.mp4", ExportFormat::H264_AAC, true, false, false, 23);
 338         encoder.go ();
 339 }
 340
 341
 342 /** Test export of a 3D DCP in a 2D project */
 343 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_3d_dcp_to_h264)
 344 {
 345         auto dcp = make_shared<DCPContent>(TestPaths::private_data() / "xm");
 346         auto film2 = new_test_film2 ("ffmpeg_encoder_3d_dcp_to_h264_export", {dcp});
 347
 348         auto job = make_shared<TranscodeJob>(film2, TranscodeJob::ChangedBehaviour::IGNORE);
 349         FFmpegEncoder encoder (film2, job, "build/test/ffmpeg_encoder_3d_dcp_to_h264.mp4", ExportFormat::H264_AAC, true, false, false, 23);
 350         encoder.go ();
 351 }
 352
 353
 354 /** Test export of a 3D DCP in a 2D project */
 355 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test7)
 356 {
 357         auto L = make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png");
 358         auto R = make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png");
 359         auto film = new_test_film2 ("ffmpeg_encoder_h264_test7_data", {L, R});
 360         L->video->set_frame_type (VideoFrameType::THREE_D_LEFT);
 361         L->set_position (film, DCPTime());
 362         R->video->set_frame_type (VideoFrameType::THREE_D_RIGHT);
 363         R->set_position (film, DCPTime());
 364         film->set_three_d (true);
 365         make_and_verify_dcp (film);
 366
 367         auto dcp = make_shared<DCPContent>(film->dir(film->dcp_name()));
 368         auto film2 = new_test_film2 ("ffmpeg_encoder_h264_test7_export", {dcp});
 369
 370         auto job = make_shared<TranscodeJob> (film2, TranscodeJob::ChangedBehaviour::IGNORE);
 371         FFmpegEncoder encoder (film2, job, "build/test/ffmpeg_encoder_h264_test7.mp4", ExportFormat::H264_AAC, true, false, false, 23);
 372         encoder.go ();
 373 }
 374
 375
 376 BOOST_AUTO_TEST_CASE(ffmpeg_encoder_2d_content_in_3d_project)
 377 {
 378         auto content = make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png");
 379         auto film = new_test_film2("ffmpeg_encoder_2d_content_in_3d_project", { content });
 380         film->set_three_d(true);
 381
 382         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 383         FFmpegEncoder encoder(film, job, "build/test/ffmpeg_encoder_2d_content_in_3d_project.mp4", ExportFormat::H264_AAC, true, false, false, 23);
 384         encoder.go();
 385 }
 386
 387
 388 /** Stereo project with mixdown-to-stereo set */
 389 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test8)
 390 {
 391         auto film = new_test_film2("ffmpeg_encoder_h264_test4");
 392         film->examine_and_add_content(make_shared<DCPContent>("test/data/scope_dcp"));
 393         BOOST_REQUIRE(!wait_for_jobs());
 394         film->set_audio_channels (2);
 395
 396         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 397         FFmpegEncoder encoder(film, job, "build/test/ffmpeg_encoder_h264_test8.mp4", ExportFormat::H264_AAC, true, false, false, 23);
 398         encoder.go();
 399 }
 400
 401
 402 /** 7.1/HI/VI (i.e. 12-channel) project */
 403 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_test9)
 404 {
 405         auto c = make_shared<ImageContent>(TestPaths::private_data() / "bbc405.png");
 406         auto film = new_test_film2("ffmpeg_encoder_prores_test9", { c });
 407         film->set_name ("ffmpeg_encoder_prores_test9");
 408         film->set_container (Ratio::from_id ("185"));
 409         film->set_audio_channels (12);
 410
 411         film->examine_and_add_content (c);
 412         BOOST_REQUIRE (!wait_for_jobs ());
 413
 414         c->video->set_length (240);
 415
 416         film->write_metadata ();
 417         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 418         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_test9.mov", ExportFormat::H264_AAC, false, false, false, 23);
 419         encoder.go ();
 420 }
 421
 422
 423 /** DCP -> Prores with crop */
 424 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_from_dcp_with_crop)
 425 {
 426         auto dcp = make_shared<DCPContent>("test/data/import_dcp_test2");
 427         auto film = new_test_film2 ("ffmpeg_encoder_prores_from_dcp_with_crop", { dcp });
 428         dcp->video->set_left_crop (32);
 429         dcp->video->set_right_crop (32);
 430         film->write_metadata ();
 431
 432         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 433         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_from_dcp_with_crop.mov", ExportFormat::PRORES_HQ, false, false, false, 23);
 434         encoder.go ();
 435 }
 436
 437
 438 /** DCP -> H264 with crop */
 439 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_from_dcp_with_crop)
 440 {
 441         auto dcp = make_shared<DCPContent>("test/data/import_dcp_test2");
 442         auto film = new_test_film2 ("ffmpeg_encoder_h264_from_dcp_with_crop", { dcp });
 443         dcp->video->set_left_crop (32);
 444         dcp->video->set_right_crop (32);
 445         film->write_metadata ();
 446
 447         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 448         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_from_dcp_with_crop.mov", ExportFormat::H264_AAC, false, false, false, 23);
 449         encoder.go ();
 450 }
 451
 452
 453 /** Export to H264 with reels */
 454 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_h264_with_reels)
 455 {
 456         auto content1 = content_factory("test/data/flat_red.png")[0];
 457         auto content2 = content_factory("test/data/flat_red.png")[0];
 458         auto film = new_test_film2 ("ffmpeg_encoder_h264_with_reels", { content1, content2 });
 459         film->set_reel_type (ReelType::BY_VIDEO_CONTENT);
 460         content1->video->set_length (240);
 461         content2->video->set_length (240);
 462
 463         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 464         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_h264_with_reels.mov", ExportFormat::H264_AAC, false, true, false, 23);
 465         encoder.go ();
 466
 467         auto check = [](boost::filesystem::path path) {
 468                 auto reel = std::dynamic_pointer_cast<FFmpegContent>(content_factory(path)[0]);
 469                 BOOST_REQUIRE (reel);
 470                 FFmpegExaminer examiner(reel);
 471                 BOOST_CHECK_EQUAL (examiner.video_length(), 240U);
 472         };
 473
 474         check ("build/test/ffmpeg_encoder_h264_with_reels_reel1.mov");
 475         check ("build/test/ffmpeg_encoder_h264_with_reels_reel2.mov");
 476 }
 477
 478
 479 /** Regression test for "Error during decoding: Butler finished" (#2097) */
 480 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_regression_1)
 481 {
 482         Cleanup cl;
 483
 484         auto content = content_factory(TestPaths::private_data() / "arrietty_JP-EN.mkv")[0];
 485         auto film = new_test_film2 ("ffmpeg_encoder_prores_regression_1", { content });
 486
 487         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 488         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_regression_1.mov", ExportFormat::PRORES_HQ, false, true, false, 23);
 489         encoder.go ();
 490
 491         cl.add("build/test/ffmpeg_encoder_prores_regression_1.mov");
 492         cl.run();
 493 }
 494
 495
 496 /** Regression test for Butler video buffers reached 480 frames (audio is 0) (#2101) */
 497 BOOST_AUTO_TEST_CASE (ffmpeg_encoder_prores_regression_2)
 498 {
 499         Cleanup cl;
 500
 501         auto logs = dcpomatic_log->types();
 502         dcpomatic_log->set_types(logs | LogEntry::TYPE_DEBUG_PLAYER);
 503
 504         auto content = content_factory(TestPaths::private_data() / "tge_clip.mkv")[0];
 505         auto film = new_test_film2 ("ffmpeg_encoder_prores_regression_2", { content });
 506
 507         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 508         FFmpegEncoder encoder (film, job, "build/test/ffmpeg_encoder_prores_regression_2.mov", ExportFormat::PRORES_HQ, false, true, false, 23);
 509         encoder.go ();
 510
 511         dcpomatic_log->set_types(logs);
 512
 513         cl.add("build/test/ffmpeg_encoder_prores_regression_2.mov");
 514         cl.run();
 515 }
 516
 517
 518 BOOST_AUTO_TEST_CASE(ffmpeg_encoder_missing_frame_at_end)
 519 {
 520         auto content = content_factory(TestPaths::private_data() / "1s1f.mov");
 521         auto film = new_test_film2("ffmpeg_encoder_missing_frame_at_end", content);
 522
 523         boost::filesystem::path output("build/test/ffmpeg_encoder_missing_frame_at_end.mov");
 524         boost::filesystem::path log("build/test/ffmpeg_encoder_missing_frame_at_end.log");
 525
 526         auto job = make_shared<TranscodeJob>(film, TranscodeJob::ChangedBehaviour::IGNORE);
 527         FFmpegEncoder encoder(film, job, output, ExportFormat::PRORES_HQ, false, true, false, 23);
 528         encoder.go();
 529
 530         run_ffprobe(output, log, false, "-show_frames -show_format -show_streams -select_streams v:0");
 531
 532         dcp::File read_log(log, "r");
 533         BOOST_REQUIRE(read_log);
 534
 535         int nb_read_frames = 0;
 536         int nb_frames = 0;
 537         char buffer[256];
 538
 539         while (!read_log.eof()) {
 540                 read_log.gets(buffer, sizeof(buffer));
 541                 vector<string> parts;
 542                 boost::algorithm::split(parts, buffer, boost::is_any_of("="));
 543                 if (parts.size() == 2) {
 544                         if (parts[0] == "nb_read_frames") {
 545                                 nb_read_frames = dcp::raw_convert<int>(parts[1]);
 546                         } else if (parts[0] == "nb_frames") {
 547                                 nb_frames = dcp::raw_convert<int>(parts[1]);
 548                         }
 549                 }
 550         }
 551
 552         BOOST_CHECK_EQUAL(nb_frames, 26);
 553         BOOST_CHECK_EQUAL(nb_read_frames, 26);
 554 }
 555