src/wx/film_viewer.cc

   1 /*
   2     Copyright (C) 2012-2019 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 /** @file  src/film_viewer.cc
  22  *  @brief A wx widget to view a preview of a Film.
  23  */
  24
  25 #include "film_viewer.h"
  26 #include "playhead_to_timecode_dialog.h"
  27 #include "playhead_to_frame_dialog.h"
  28 #include "wx_util.h"
  29 #include "closed_captions_dialog.h"
  30 #include "gl_video_view.h"
  31 #include "simple_video_view.h"
  32 #include "lib/film.h"
  33 #include "lib/ratio.h"
  34 #include "lib/util.h"
  35 #include "lib/job_manager.h"
  36 #include "lib/image.h"
  37 #include "lib/exceptions.h"
  38 #include "lib/examine_content_job.h"
  39 #include "lib/filter.h"
  40 #include "lib/player.h"
  41 #include "lib/player_video.h"
  42 #include "lib/video_content.h"
  43 #include "lib/video_decoder.h"
  44 #include "lib/timer.h"
  45 #include "lib/butler.h"
  46 #include "lib/log.h"
  47 #include "lib/config.h"
  48 #include "lib/compose.hpp"
  49 #include "lib/dcpomatic_log.h"
  50 extern "C" {
  51 #include <libavutil/pixfmt.h>
  52 }
  53 #include <dcp/exceptions.h>
  54 #include <wx/tglbtn.h>
  55 #include <iostream>
  56 #include <iomanip>
  57
  58 using std::string;
  59 using std::pair;
  60 using std::min;
  61 using std::max;
  62 using std::cout;
  63 using std::list;
  64 using std::bad_alloc;
  65 using std::make_pair;
  66 using std::exception;
  67 using boost::shared_ptr;
  68 using boost::dynamic_pointer_cast;
  69 using boost::weak_ptr;
  70 using boost::optional;
  71 using dcp::Size;
  72 using namespace dcpomatic;
  73
  74 static
  75 int
  76 rtaudio_callback (void* out, void *, unsigned int frames, double, RtAudioStreamStatus, void* data)
  77 {
  78         return reinterpret_cast<FilmViewer*>(data)->audio_callback (out, frames);
  79 }
  80
  81 FilmViewer::FilmViewer (wxWindow* p)
  82         : _coalesce_player_changes (false)
  83         , _audio (DCPOMATIC_RTAUDIO_API)
  84         , _audio_channels (0)
  85         , _audio_block_size (1024)
  86         , _playing (false)
  87         , _latency_history_count (0)
  88         , _dropped (0)
  89         , _closed_captions_dialog (new ClosedCaptionsDialog(p, this))
  90         , _outline_content (false)
  91         , _eyes (EYES_LEFT)
  92         , _pad_black (false)
  93 #ifdef DCPOMATIC_VARIANT_SWAROOP
  94         , _background_image (false)
  95 #endif
  96         , _state_timer ("viewer")
  97         , _gets (0)
  98 {
  99         switch (Config::instance()->video_view_type()) {
 100         case Config::VIDEO_VIEW_OPENGL:
 101                 _video_view = new GLVideoView (this, p);
 102                 break;
 103         case Config::VIDEO_VIEW_SIMPLE:
 104                 _video_view = new SimpleVideoView (this, p);
 105                 break;
 106         }
 107
 108         _video_view->Sized.connect (boost::bind(&FilmViewer::video_view_sized, this));
 109         _timer.Bind (wxEVT_TIMER, boost::bind(&FilmViewer::timer, this));
 110
 111         set_film (shared_ptr<Film> ());
 112
 113         _config_changed_connection = Config::instance()->Changed.connect (bind (&FilmViewer::config_changed, this, _1));
 114         config_changed (Config::SOUND_OUTPUT);
 115 }
 116
 117 FilmViewer::~FilmViewer ()
 118 {
 119         stop ();
 120 }
 121
 122 void
 123 FilmViewer::set_film (shared_ptr<Film> film)
 124 {
 125         if (_film == film) {
 126                 return;
 127         }
 128
 129         _film = film;
 130         _video_position = DCPTime ();
 131         _player_video.first.reset ();
 132         _player_video.second = DCPTime ();
 133
 134         _video_view->set_image (shared_ptr<Image>());
 135         _closed_captions_dialog->clear ();
 136
 137         if (!_film) {
 138                 _player.reset ();
 139                 recreate_butler ();
 140                 refresh_view ();
 141                 return;
 142         }
 143
 144         try {
 145                 _player.reset (new Player (_film, _film->playlist ()));
 146                 _player->set_fast ();
 147                 if (_dcp_decode_reduction) {
 148                         _player->set_dcp_decode_reduction (_dcp_decode_reduction);
 149                 }
 150         } catch (bad_alloc &) {
 151                 error_dialog (_video_view->get(), _("There is not enough free memory to do that."));
 152                 _film.reset ();
 153                 return;
 154         }
 155
 156         _player->set_always_burn_open_subtitles ();
 157         _player->set_play_referenced ();
 158
 159         _film->Change.connect (boost::bind (&FilmViewer::film_change, this, _1, _2));
 160         _player->Change.connect (boost::bind (&FilmViewer::player_change, this, _1, _2, _3));
 161
 162         /* Keep about 1 second's worth of history samples */
 163         _latency_history_count = _film->audio_frame_rate() / _audio_block_size;
 164
 165         recreate_butler ();
 166
 167         calculate_sizes ();
 168         slow_refresh ();
 169 }
 170
 171 void
 172 FilmViewer::recreate_butler ()
 173 {
 174         bool const was_running = stop ();
 175         _butler.reset ();
 176
 177         if (!_film) {
 178                 return;
 179         }
 180
 181         AudioMapping map = AudioMapping (_film->audio_channels(), _audio_channels);
 182
 183         if (_audio_channels != 2 || _film->audio_channels() < 3) {
 184                 for (int i = 0; i < min (_film->audio_channels(), _audio_channels); ++i) {
 185                         map.set (i, i, 1);
 186                 }
 187         } else {
 188                 /* Special case: stereo output, at least 3 channel input.
 189                    Map so that Lt = L(-3dB) + Ls(-3dB) + C(-6dB) + Lfe(-10dB)
 190                                Rt = R(-3dB) + Rs(-3dB) + C(-6dB) + Lfe(-10dB)
 191                 */
 192                 map.set (dcp::LEFT,   0, 1 / sqrt(2)); // L -> Lt
 193                 map.set (dcp::RIGHT,  1, 1 / sqrt(2)); // R -> Rt
 194                 map.set (dcp::CENTRE, 0, 1 / 2.0); // C -> Lt
 195                 map.set (dcp::CENTRE, 1, 1 / 2.0); // C -> Rt
 196                 map.set (dcp::LFE,    0, 1 / sqrt(10)); // Lfe -> Lt
 197                 map.set (dcp::LFE,    1, 1 / sqrt(10)); // Lfe -> Rt
 198                 map.set (dcp::LS,     0, 1 / sqrt(2)); // Ls -> Lt
 199                 map.set (dcp::RS,     1, 1 / sqrt(2)); // Rs -> Rt
 200         }
 201
 202         _butler.reset (new Butler(_player, map, _audio_channels, bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24), false, true));
 203         if (!Config::instance()->sound() && !_audio.isStreamOpen()) {
 204                 _butler->disable_audio ();
 205         }
 206
 207         _closed_captions_dialog->set_film_and_butler (_film, _butler);
 208
 209         if (was_running) {
 210                 start ();
 211         }
 212 }
 213
 214 void
 215 FilmViewer::refresh_view ()
 216 {
 217         _state_timer.set ("update-view");
 218         _video_view->update ();
 219         _state_timer.unset ();
 220 }
 221
 222 void
 223 FilmViewer::get ()
 224 {
 225         DCPOMATIC_ASSERT (_butler);
 226         ++_gets;
 227
 228         do {
 229                 Butler::Error e;
 230                 _player_video = _butler->get_video (&e);
 231                 if (!_player_video.first && e == Butler::AGAIN) {
 232                         signal_manager->when_idle (boost::bind(&FilmViewer::get, this));
 233                         return;
 234                 }
 235         } while (
 236                 _player_video.first &&
 237                 _film->three_d() &&
 238                 _eyes != _player_video.first->eyes() &&
 239                 _player_video.first->eyes() != EYES_BOTH
 240                 );
 241
 242         try {
 243                 _butler->rethrow ();
 244         } catch (DecodeError& e) {
 245                 error_dialog (_video_view->get(), e.what());
 246         }
 247
 248         display_player_video ();
 249 }
 250
 251 void
 252 FilmViewer::display_player_video ()
 253 {
 254         if (!_player_video.first) {
 255                 _video_view->set_image (shared_ptr<Image>());
 256                 refresh_view ();
 257                 return;
 258         }
 259
 260         if (_playing && (time() - _player_video.second) > one_video_frame()) {
 261                 /* Too late; just drop this frame before we try to get its image (which will be the time-consuming
 262                    part if this frame is J2K).
 263                 */
 264                 _video_position = _player_video.second;
 265                 ++_dropped;
 266                 return;
 267         }
 268
 269         /* In an ideal world, what we would do here is:
 270          *
 271          * 1. convert to XYZ exactly as we do in the DCP creation path.
 272          * 2. convert back to RGB for the preview display, compensating
 273          *    for the monitor etc. etc.
 274          *
 275          * but this is inefficient if the source is RGB.  Since we don't
 276          * (currently) care too much about the precise accuracy of the preview's
 277          * colour mapping (and we care more about its speed) we try to short-
 278          * circuit this "ideal" situation in some cases.
 279          *
 280          * The content's specified colour conversion indicates the colourspace
 281          * which the content is in (according to the user).
 282          *
 283          * PlayerVideo::image (bound to PlayerVideo::force) will take the source
 284          * image and convert it (from whatever the user has said it is) to RGB.
 285          */
 286
 287         _state_timer.set ("get image");
 288
 289         _video_view->set_image (
 290                 _player_video.first->image(bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24), false, true)
 291                 );
 292
 293         _state_timer.set ("ImageChanged");
 294         ImageChanged (_player_video.first);
 295         _state_timer.unset ();
 296
 297         _video_position = _player_video.second;
 298         _inter_position = _player_video.first->inter_position ();
 299         _inter_size = _player_video.first->inter_size ();
 300
 301         refresh_view ();
 302
 303         _closed_captions_dialog->update (time());
 304 }
 305
 306 void
 307 FilmViewer::timer ()
 308 {
 309         if (!_film || !_playing) {
 310                 return;
 311         }
 312
 313         get ();
 314         PositionChanged ();
 315         DCPTime const next = _video_position + one_video_frame();
 316
 317         if (next >= _film->length()) {
 318                 stop ();
 319                 Finished ();
 320                 return;
 321         }
 322
 323         LOG_DEBUG_PLAYER("%1 -> %2; delay %3", next.seconds(), time().seconds(), max((next.seconds() - time().seconds()) * 1000, 1.0));
 324         _timer.Start (max ((next.seconds() - time().seconds()) * 1000, 1.0), wxTIMER_ONE_SHOT);
 325
 326         if (_butler) {
 327                 _butler->rethrow ();
 328         }
 329 }
 330
 331 void
 332 FilmViewer::set_outline_content (bool o)
 333 {
 334         _outline_content = o;
 335         refresh_view ();
 336 }
 337
 338 void
 339 FilmViewer::set_eyes (Eyes e)
 340 {
 341         _eyes = e;
 342         slow_refresh ();
 343 }
 344
 345 void
 346 FilmViewer::video_view_sized ()
 347 {
 348         calculate_sizes ();
 349         if (!quick_refresh()) {
 350                 slow_refresh ();
 351         }
 352         PositionChanged ();
 353 }
 354
 355 void
 356 FilmViewer::calculate_sizes ()
 357 {
 358         if (!_film || !_player) {
 359                 return;
 360         }
 361
 362         Ratio const * container = _film->container ();
 363
 364         float const view_ratio = float(_video_view->get()->GetSize().x) / _video_view->get()->GetSize().y;
 365         float const film_ratio = container ? container->ratio () : 1.78;
 366
 367         if (view_ratio < film_ratio) {
 368                 /* panel is less widscreen than the film; clamp width */
 369                 _out_size.width = _video_view->get()->GetSize().x;
 370                 _out_size.height = lrintf (_out_size.width / film_ratio);
 371         } else {
 372                 /* panel is more widescreen than the film; clamp height */
 373                 _out_size.height = _video_view->get()->GetSize().y;
 374                 _out_size.width = lrintf (_out_size.height * film_ratio);
 375         }
 376
 377         /* Catch silly values */
 378         _out_size.width = max (64, _out_size.width);
 379         _out_size.height = max (64, _out_size.height);
 380
 381         _player->set_video_container_size (_out_size);
 382 }
 383
 384 void
 385 FilmViewer::start ()
 386 {
 387         if (!_film) {
 388                 return;
 389         }
 390
 391         optional<bool> v = PlaybackPermitted ();
 392         if (v && !*v) {
 393                 /* Computer says no */
 394                 return;
 395         }
 396
 397         if (_audio.isStreamOpen()) {
 398                 _audio.setStreamTime (_video_position.seconds());
 399                 _audio.startStream ();
 400         }
 401
 402         _playing = true;
 403         _dropped = 0;
 404         timer ();
 405         Started (position());
 406 }
 407
 408 bool
 409 FilmViewer::stop ()
 410 {
 411         if (_audio.isStreamRunning()) {
 412                 /* stop stream and discard any remaining queued samples */
 413                 _audio.abortStream ();
 414         }
 415
 416         if (!_playing) {
 417                 return false;
 418         }
 419
 420         _playing = false;
 421         Stopped (position());
 422         return true;
 423 }
 424
 425 void
 426 FilmViewer::player_change (ChangeType type, int property, bool frequent)
 427 {
 428         if (type != CHANGE_TYPE_DONE || frequent) {
 429                 return;
 430         }
 431
 432         if (_coalesce_player_changes) {
 433                 _pending_player_changes.push_back (property);
 434                 return;
 435         }
 436
 437         calculate_sizes ();
 438         bool refreshed = false;
 439         if (
 440                 property == VideoContentProperty::CROP ||
 441                 property == VideoContentProperty::SCALE ||
 442                 property == VideoContentProperty::FADE_IN ||
 443                 property == VideoContentProperty::FADE_OUT ||
 444                 property == VideoContentProperty::COLOUR_CONVERSION ||
 445                 property == PlayerProperty::VIDEO_CONTAINER_SIZE ||
 446                 property == PlayerProperty::FILM_CONTAINER
 447                 ) {
 448                 refreshed = quick_refresh ();
 449         }
 450
 451         if (!refreshed) {
 452                 slow_refresh ();
 453         }
 454         PositionChanged ();
 455 }
 456
 457 void
 458 FilmViewer::film_change (ChangeType type, Film::Property p)
 459 {
 460         if (type == CHANGE_TYPE_DONE && p == Film::AUDIO_CHANNELS) {
 461                 recreate_butler ();
 462         }
 463 }
 464
 465 /** Re-get the current frame slowly by seeking */
 466 void
 467 FilmViewer::slow_refresh ()
 468 {
 469         seek (_video_position, true);
 470 }
 471
 472 /** Try to re-get the current frame quickly by resetting the metadata
 473  *  in the PlayerVideo that we used last time.
 474  *  @return true if this was possible, false if not.
 475  */
 476 bool
 477 FilmViewer::quick_refresh ()
 478 {
 479         if (!_player_video.first) {
 480                 return false;
 481         }
 482
 483         if (!_player_video.first->reset_metadata (_film, _player->video_container_size(), _film->frame_size())) {
 484                 return false;
 485         }
 486
 487         display_player_video ();
 488         return true;
 489 }
 490
 491 void
 492 FilmViewer::seek (shared_ptr<Content> content, ContentTime t, bool accurate)
 493 {
 494         optional<DCPTime> dt = _player->content_time_to_dcp (content, t);
 495         if (dt) {
 496                 seek (*dt, accurate);
 497         }
 498 }
 499
 500 void
 501 FilmViewer::set_coalesce_player_changes (bool c)
 502 {
 503         _coalesce_player_changes = c;
 504
 505         if (!c) {
 506                 BOOST_FOREACH (int i, _pending_player_changes) {
 507                         player_change (CHANGE_TYPE_DONE, i, false);
 508                 }
 509                 _pending_player_changes.clear ();
 510         }
 511 }
 512
 513 void
 514 FilmViewer::seek (DCPTime t, bool accurate)
 515 {
 516         if (!_butler) {
 517                 return;
 518         }
 519
 520         if (t < DCPTime ()) {
 521                 t = DCPTime ();
 522         }
 523
 524         if (t >= _film->length ()) {
 525                 t = _film->length ();
 526         }
 527
 528         bool const was_running = stop ();
 529
 530         _closed_captions_dialog->clear ();
 531         _butler->seek (t, accurate);
 532         get ();
 533
 534         if (was_running) {
 535                 start ();
 536         }
 537
 538         PositionChanged ();
 539 }
 540
 541 void
 542 FilmViewer::config_changed (Config::Property p)
 543 {
 544 #ifdef DCPOMATIC_VARIANT_SWAROOP
 545         if (p == Config::PLAYER_BACKGROUND_IMAGE) {
 546                 refresh_view ();
 547                 return;
 548         }
 549 #endif
 550
 551         if (p != Config::SOUND && p != Config::SOUND_OUTPUT) {
 552                 return;
 553         }
 554
 555         if (_audio.isStreamOpen ()) {
 556                 _audio.closeStream ();
 557         }
 558
 559         if (Config::instance()->sound() && _audio.getDeviceCount() > 0) {
 560                 unsigned int st = 0;
 561                 if (Config::instance()->sound_output()) {
 562                         while (st < _audio.getDeviceCount()) {
 563                                 if (_audio.getDeviceInfo(st).name == Config::instance()->sound_output().get()) {
 564                                         break;
 565                                 }
 566                                 ++st;
 567                         }
 568                         if (st == _audio.getDeviceCount()) {
 569                                 st = _audio.getDefaultOutputDevice();
 570                         }
 571                 } else {
 572                         st = _audio.getDefaultOutputDevice();
 573                 }
 574
 575                 _audio_channels = _audio.getDeviceInfo(st).outputChannels;
 576
 577                 RtAudio::StreamParameters sp;
 578                 sp.deviceId = st;
 579                 sp.nChannels = _audio_channels;
 580                 sp.firstChannel = 0;
 581                 try {
 582                         _audio.openStream (&sp, 0, RTAUDIO_FLOAT32, 48000, &_audio_block_size, &rtaudio_callback, this);
 583 #ifdef DCPOMATIC_USE_RTERROR
 584                 } catch (RtError& e) {
 585 #else
 586                 } catch (RtAudioError& e) {
 587 #endif
 588                         error_dialog (
 589                                 _video_view->get(),
 590                                 _("Could not set up audio output.  There will be no audio during the preview."), std_to_wx(e.what())
 591                                 );
 592                 }
 593                 recreate_butler ();
 594
 595         } else {
 596                 _audio_channels = 0;
 597                 recreate_butler ();
 598         }
 599 }
 600
 601 DCPTime
 602 FilmViewer::uncorrected_time () const
 603 {
 604         if (_audio.isStreamRunning ()) {
 605                 return DCPTime::from_seconds (const_cast<RtAudio*>(&_audio)->getStreamTime());
 606         }
 607
 608         return _video_position;
 609 }
 610
 611 DCPTime
 612 FilmViewer::time () const
 613 {
 614         if (_audio.isStreamRunning ()) {
 615                 return DCPTime::from_seconds (const_cast<RtAudio*>(&_audio)->getStreamTime ()) -
 616                         DCPTime::from_frames (average_latency(), _film->audio_frame_rate());
 617         }
 618
 619         return _video_position;
 620 }
 621
 622 int
 623 FilmViewer::audio_callback (void* out_p, unsigned int frames)
 624 {
 625         while (true) {
 626                 optional<DCPTime> t = _butler->get_audio (reinterpret_cast<float*> (out_p), frames);
 627                 if (!t || DCPTime(uncorrected_time() - *t) < one_video_frame()) {
 628                         /* There was an underrun or this audio is on time; carry on */
 629                         break;
 630                 }
 631                 /* The audio we just got was (very) late; drop it and get some more. */
 632         }
 633
 634         boost::mutex::scoped_lock lm (_latency_history_mutex, boost::try_to_lock);
 635         if (lm) {
 636                 _latency_history.push_back (_audio.getStreamLatency ());
 637                 if (_latency_history.size() > static_cast<size_t> (_latency_history_count)) {
 638                         _latency_history.pop_front ();
 639                 }
 640         }
 641
 642         return 0;
 643 }
 644
 645 Frame
 646 FilmViewer::average_latency () const
 647 {
 648         boost::mutex::scoped_lock lm (_latency_history_mutex);
 649         if (_latency_history.empty()) {
 650                 return 0;
 651         }
 652
 653         Frame total = 0;
 654         BOOST_FOREACH (Frame i, _latency_history) {
 655                 total += i;
 656         }
 657
 658         return total / _latency_history.size();
 659 }
 660
 661 void
 662 FilmViewer::set_dcp_decode_reduction (optional<int> reduction)
 663 {
 664         _dcp_decode_reduction = reduction;
 665         if (_player) {
 666                 _player->set_dcp_decode_reduction (reduction);
 667         }
 668 }
 669
 670 optional<int>
 671 FilmViewer::dcp_decode_reduction () const
 672 {
 673         return _dcp_decode_reduction;
 674 }
 675
 676 DCPTime
 677 FilmViewer::one_video_frame () const
 678 {
 679         return DCPTime::from_frames (1, _film->video_frame_rate());
 680 }
 681
 682 /** Open a dialog box showing our film's closed captions */
 683 void
 684 FilmViewer::show_closed_captions ()
 685 {
 686         _closed_captions_dialog->Show();
 687 }
 688
 689 void
 690 FilmViewer::seek_by (DCPTime by, bool accurate)
 691 {
 692         seek (_video_position + by, accurate);
 693 }
 694
 695 void
 696 FilmViewer::set_pad_black (bool p)
 697 {
 698         _pad_black = p;
 699 }