X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Fwx%2Ffilm_viewer.cc;h=0e6e908b3245c88fb8e9851e4e898a452c8d64bb;hp=8ed566bfcbd5ce39abcfa836c25797128e38de87;hb=4b76291eb0328840de4c5938a1be6340e5dea0fe;hpb=d17430d78742027b1e6b9098269a34f4742a4b6a diff --git a/src/wx/film_viewer.cc b/src/wx/film_viewer.cc index 8ed566bfc..0e6e908b3 100644 --- a/src/wx/film_viewer.cc +++ b/src/wx/film_viewer.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2019 Carl Hetherington + Copyright (C) 2012-2021 Carl Hetherington This file is part of DCP-o-matic. @@ -18,58 +18,65 @@ */ + /** @file src/film_viewer.cc * @brief A wx widget to view a preview of a Film. */ + +#include "closed_captions_dialog.h" #include "film_viewer.h" -#include "playhead_to_timecode_dialog.h" +#include "gl_video_view.h" +#include "nag_dialog.h" #include "playhead_to_frame_dialog.h" +#include "playhead_to_timecode_dialog.h" +#include "simple_video_view.h" #include "wx_util.h" -#include "closed_captions_dialog.h" -#include "gl_video_view.h" -#include "lib/film.h" -#include "lib/ratio.h" -#include "lib/util.h" -#include "lib/job_manager.h" -#include "lib/image.h" -#include "lib/exceptions.h" +#include "lib/butler.h" +#include "lib/compose.hpp" +#include "lib/config.h" +#include "lib/dcpomatic_log.h" #include "lib/examine_content_job.h" +#include "lib/exceptions.h" +#include "lib/film.h" #include "lib/filter.h" +#include "lib/image.h" +#include "lib/job_manager.h" +#include "lib/log.h" #include "lib/player.h" #include "lib/player_video.h" +#include "lib/ratio.h" +#include "lib/text_content.h" +#include "lib/timer.h" +#include "lib/util.h" #include "lib/video_content.h" #include "lib/video_decoder.h" -#include "lib/timer.h" -#include "lib/butler.h" -#include "lib/log.h" -#include "lib/config.h" -#include "lib/compose.hpp" -#include "lib/dcpomatic_log.h" +#include +#include extern "C" { #include } -#include +LIBDCP_DISABLE_WARNINGS #include -#include +LIBDCP_ENABLE_WARNINGS #include -using std::string; -using std::pair; -using std::min; -using std::max; -using std::cout; -using std::list; + using std::bad_alloc; -using std::make_pair; -using std::exception; -using boost::shared_ptr; -using boost::dynamic_pointer_cast; -using boost::weak_ptr; +using std::dynamic_pointer_cast; +using std::make_shared; +using std::max; +using std::shared_ptr; +using std::string; +using std::vector; using boost::optional; +#if BOOST_VERSION >= 106100 +using namespace boost::placeholders; +#endif using dcp::Size; using namespace dcpomatic; + static int rtaudio_callback (void* out, void *, unsigned int frames, double, RtAudioStreamStatus, void* data) @@ -77,42 +84,70 @@ rtaudio_callback (void* out, void *, unsigned int frames, double, RtAudioStreamS return reinterpret_cast(data)->audio_callback (out, frames); } + FilmViewer::FilmViewer (wxWindow* p) - /* XXX: make this configurable */ - : _video_view (new GLVideoView(p)) - , _coalesce_player_changes (false) - , _audio (DCPOMATIC_RTAUDIO_API) - , _audio_channels (0) - , _audio_block_size (1024) - , _playing (false) - , _latency_history_count (0) - , _dropped (0) + : _audio (DCPOMATIC_RTAUDIO_API) , _closed_captions_dialog (new ClosedCaptionsDialog(p, this)) - , _outline_content (false) - , _eyes (EYES_LEFT) - , _pad_black (false) -#ifdef DCPOMATIC_VARIANT_SWAROOP - , _in_watermark (false) - , _background_image (false) -#endif - , _state_timer ("viewer") - , _gets (0) { - /* XXX: maybe this should be proxied through the VideoView */ - _video_view->get()->Bind (wxEVT_SIZE, boost::bind (&FilmViewer::video_view_sized, this)); - _timer.Bind (wxEVT_TIMER, boost::bind (&FilmViewer::timer, this)); +#if wxCHECK_VERSION(3, 1, 0) + switch (Config::instance()->video_view_type()) { + case Config::VIDEO_VIEW_OPENGL: + _video_view = std::make_shared(this, p); + break; + case Config::VIDEO_VIEW_SIMPLE: + _video_view = std::make_shared(this, p); + break; + } +#else + _video_view = std::make_shared(this, p); +#endif + + _video_view->Sized.connect (boost::bind(&FilmViewer::video_view_sized, this)); + _video_view->TooManyDropped.connect (boost::bind(boost::ref(TooManyDropped))); - set_film (shared_ptr ()); + set_film (shared_ptr()); - _config_changed_connection = Config::instance()->Changed.connect (bind (&FilmViewer::config_changed, this, _1)); + _config_changed_connection = Config::instance()->Changed.connect(bind(&FilmViewer::config_changed, this, _1)); config_changed (Config::SOUND_OUTPUT); } + FilmViewer::~FilmViewer () { stop (); } + +/** Ask for ::idle_handler() to be called next time we are idle */ +void +FilmViewer::request_idle_display_next_frame () +{ + if (_idle_get) { + return; + } + + _idle_get = true; + DCPOMATIC_ASSERT (signal_manager); + signal_manager->when_idle (boost::bind(&FilmViewer::idle_handler, this)); +} + + +void +FilmViewer::idle_handler () +{ + if (!_idle_get) { + return; + } + + if (_video_view->display_next_frame(true) == VideoView::AGAIN) { + /* get() could not complete quickly so we'll try again later */ + signal_manager->when_idle (boost::bind(&FilmViewer::idle_handler, this)); + } else { + _idle_get = false; + } +} + + void FilmViewer::set_film (shared_ptr film) { @@ -121,23 +156,19 @@ FilmViewer::set_film (shared_ptr film) } _film = film; - _video_position = DCPTime (); - _player_video.first.reset (); - _player_video.second = DCPTime (); - _frame.reset (); + _video_view->clear (); _closed_captions_dialog->clear (); if (!_film) { _player.reset (); recreate_butler (); - _frame.reset (); - refresh_panel (); + _video_view->update (); return; } try { - _player.reset (new Player (_film, _film->playlist ())); + _player = make_shared(_film, _optimise_for_j2k ? Image::Alignment::COMPACT : Image::Alignment::PADDED); _player->set_fast (); if (_dcp_decode_reduction) { _player->set_dcp_decode_reduction (_dcp_decode_reduction); @@ -152,210 +183,88 @@ FilmViewer::set_film (shared_ptr film) _player->set_play_referenced (); _film->Change.connect (boost::bind (&FilmViewer::film_change, this, _1, _2)); + _film->LengthChange.connect (boost::bind(&FilmViewer::film_length_change, this)); _player->Change.connect (boost::bind (&FilmViewer::player_change, this, _1, _2, _3)); + film_change (ChangeType::DONE, Film::Property::VIDEO_FRAME_RATE); + film_change (ChangeType::DONE, Film::Property::THREE_D); + film_length_change (); + /* Keep about 1 second's worth of history samples */ _latency_history_count = _film->audio_frame_rate() / _audio_block_size; + _closed_captions_dialog->update_tracks (_film); + recreate_butler (); calculate_sizes (); slow_refresh (); } + void FilmViewer::recreate_butler () { - bool const was_running = stop (); + suspend (); _butler.reset (); if (!_film) { + resume (); return; } - AudioMapping map = AudioMapping (_film->audio_channels(), _audio_channels); +#if wxCHECK_VERSION(3, 1, 0) + auto const j2k_gl_optimised = dynamic_pointer_cast(_video_view) && _optimise_for_j2k; +#else + auto const j2k_gl_optimised = false; +#endif - if (_audio_channels != 2 || _film->audio_channels() < 3) { - for (int i = 0; i < min (_film->audio_channels(), _audio_channels); ++i) { - map.set (i, i, 1); - } - } else { - /* Special case: stereo output, at least 3 channel input. - Map so that Lt = L(-3dB) + Ls(-3dB) + C(-6dB) + Lfe(-10dB) - Rt = R(-3dB) + Rs(-3dB) + C(-6dB) + Lfe(-10dB) - */ - map.set (dcp::LEFT, 0, 1 / sqrt(2)); // L -> Lt - map.set (dcp::RIGHT, 1, 1 / sqrt(2)); // R -> Rt - map.set (dcp::CENTRE, 0, 1 / 2.0); // C -> Lt - map.set (dcp::CENTRE, 1, 1 / 2.0); // C -> Rt - map.set (dcp::LFE, 0, 1 / sqrt(10)); // Lfe -> Lt - map.set (dcp::LFE, 1, 1 / sqrt(10)); // Lfe -> Rt - map.set (dcp::LS, 0, 1 / sqrt(2)); // Ls -> Lt - map.set (dcp::RS, 1, 1 / sqrt(2)); // Rs -> Rt - } + _butler = std::make_shared( + _film, + _player, + Config::instance()->audio_mapping(_audio_channels), + _audio_channels, + boost::bind(&PlayerVideo::force, AV_PIX_FMT_RGB24), + VideoRange::FULL, + j2k_gl_optimised ? Image::Alignment::COMPACT : Image::Alignment::PADDED, + true, + j2k_gl_optimised + ); - _butler.reset (new Butler(_player, map, _audio_channels, bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24), false, true)); if (!Config::instance()->sound() && !_audio.isStreamOpen()) { _butler->disable_audio (); } - _closed_captions_dialog->set_film_and_butler (_film, _butler); + _closed_captions_dialog->set_butler (_butler); - if (was_running) { - start (); - } + resume (); } -void -FilmViewer::refresh_panel () -{ - _state_timer.set ("refresh-panel"); - _video_view->get()->Refresh (); - _video_view->get()->Update (); - _state_timer.unset (); -} void -FilmViewer::get () +FilmViewer::set_outline_content (bool o) { - DCPOMATIC_ASSERT (_butler); - ++_gets; - - do { - Butler::Error e; - _player_video = _butler->get_video (&e); - if (!_player_video.first && e == Butler::AGAIN) { - signal_manager->when_idle (boost::bind(&FilmViewer::get, this)); - return; - } - } while ( - _player_video.first && - _film->three_d() && - _eyes != _player_video.first->eyes() && - _player_video.first->eyes() != EYES_BOTH - ); - - _butler->rethrow (); - - display_player_video (); + _outline_content = o; + _video_view->update (); } -void -FilmViewer::display_player_video () -{ - if (!_player_video.first) { - _frame.reset (); - refresh_panel (); - return; - } - - if (_playing && (time() - _player_video.second) > one_video_frame()) { - /* Too late; just drop this frame before we try to get its image (which will be the time-consuming - part if this frame is J2K). - */ - _video_position = _player_video.second; - ++_dropped; - return; - } - - /* In an ideal world, what we would do here is: - * - * 1. convert to XYZ exactly as we do in the DCP creation path. - * 2. convert back to RGB for the preview display, compensating - * for the monitor etc. etc. - * - * but this is inefficient if the source is RGB. Since we don't - * (currently) care too much about the precise accuracy of the preview's - * colour mapping (and we care more about its speed) we try to short- - * circuit this "ideal" situation in some cases. - * - * The content's specified colour conversion indicates the colourspace - * which the content is in (according to the user). - * - * PlayerVideo::image (bound to PlayerVideo::force) will take the source - * image and convert it (from whatever the user has said it is) to RGB. - */ - - _state_timer.set ("get image"); - - /* XXX: do we need to store _frame? */ - _frame = _player_video.first->image (bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24), false, true); - _video_view->set_image (_frame); - - _state_timer.set ("ImageChanged"); - ImageChanged (_player_video.first); - _state_timer.unset (); - - _video_position = _player_video.second; - _inter_position = _player_video.first->inter_position (); - _inter_size = _player_video.first->inter_size (); - - refresh_panel (); - - _closed_captions_dialog->update (time()); -} void -FilmViewer::timer () -{ - if (!_film || !_playing) { - return; - } - - get (); - PositionChanged (); - DCPTime const next = _video_position + one_video_frame(); - - if (next >= _film->length()) { - stop (); - Finished (); - return; - } - - LOG_DEBUG_PLAYER("%1 -> %2; delay %3", next.seconds(), time().seconds(), max((next.seconds() - time().seconds()) * 1000, 1.0)); - _timer.Start (max ((next.seconds() - time().seconds()) * 1000, 1.0), wxTIMER_ONE_SHOT); - - if (_butler) { - _butler->rethrow (); - } -} - -bool -#ifdef DCPOMATIC_VARIANT_SWAROOP -XXX -FilmViewer::maybe_draw_background_image (wxPaintDC& dc) -{ - optional bg = Config::instance()->player_background_image(); - if (bg) { - wxImage image (std_to_wx(bg->string())); - wxBitmap bitmap (image); - dc.DrawBitmap (bitmap, max(0, (_panel_size.width - image.GetSize().GetWidth()) / 2), max(0, (_panel_size.height - image.GetSize().GetHeight()) / 2)); - return true; - } - - return false; -} -#else -FilmViewer::maybe_draw_background_image (wxPaintDC &) +FilmViewer::set_outline_subtitles (optional> rect) { - return false; + _outline_subtitles = rect; + _video_view->update (); } -#endif -void -FilmViewer::set_outline_content (bool o) -{ - _outline_content = o; - refresh_panel (); -} void FilmViewer::set_eyes (Eyes e) { - _eyes = e; + _video_view->set_eyes (e); slow_refresh (); } + void FilmViewer::video_view_sized () { @@ -363,9 +272,9 @@ FilmViewer::video_view_sized () if (!quick_refresh()) { slow_refresh (); } - PositionChanged (); } + void FilmViewer::calculate_sizes () { @@ -373,32 +282,74 @@ FilmViewer::calculate_sizes () return; } - Ratio const * container = _film->container (); + auto const container = _film->container (); - float const view_ratio = float(_video_view->get()->GetSize().x) / _video_view->get()->GetSize().y; - float const film_ratio = container ? container->ratio () : 1.78; + auto const scale = dpi_scale_factor (_video_view->get()); + int const video_view_width = std::round(_video_view->get()->GetSize().x * scale); + int const video_view_height = std::round(_video_view->get()->GetSize().y * scale); + auto const view_ratio = float(video_view_width) / video_view_height; + auto const film_ratio = container ? container->ratio () : 1.78; + + dcp::Size out_size; if (view_ratio < film_ratio) { /* panel is less widscreen than the film; clamp width */ - _out_size.width = _video_view->get()->GetSize().x; - _out_size.height = lrintf (_out_size.width / film_ratio); + out_size.width = video_view_width; + out_size.height = lrintf (out_size.width / film_ratio); } else { /* panel is more widescreen than the film; clamp height */ - _out_size.height = _video_view->get()->GetSize().y; - _out_size.width = lrintf (_out_size.height * film_ratio); + out_size.height = video_view_height; + out_size.width = lrintf (out_size.height * film_ratio); } /* Catch silly values */ - _out_size.width = max (64, _out_size.width); - _out_size.height = max (64, _out_size.height); + out_size.width = max (64, out_size.width); + out_size.height = max (64, out_size.height); + + _player->set_video_container_size (out_size); +} + + +void +FilmViewer::suspend () +{ + ++_suspended; + if (_audio.isStreamRunning()) { + _audio.abortStream(); + } +} - /* Make OpenGL happy; XXX: only do this in GLVideoView? Is the round-to-4 constraint a thing? */ - _out_size.width &= ~3; - _out_size.height &= ~3; - _player->set_video_container_size (_out_size); +void +FilmViewer::start_audio_stream_if_open () +{ + if (_audio.isStreamOpen()) { + _audio.setStreamTime (_video_view->position().seconds()); + try { + _audio.startStream (); + } catch (RtAudioError& e) { + _audio_channels = 0; + error_dialog ( + _video_view->get(), + _("There was a problem starting audio playback. Please try another audio output device in Preferences."), std_to_wx(e.what()) + ); + } + } } + +void +FilmViewer::resume () +{ + DCPOMATIC_ASSERT (_suspended > 0); + --_suspended; + if (_playing && !_suspended) { + start_audio_stream_if_open (); + _video_view->start (); + } +} + + void FilmViewer::start () { @@ -406,23 +357,34 @@ FilmViewer::start () return; } - optional v = PlaybackPermitted (); + auto v = PlaybackPermitted (); if (v && !*v) { /* Computer says no */ return; } - if (_audio.isStreamOpen()) { - _audio.setStreamTime (_video_position.seconds()); - _audio.startStream (); + /* We are about to set up the audio stream from the position of the video view. + If there is `lazy' seek in progress we need to wait for it to go through so that + _video_view->position() gives us a sensible answer. + */ + while (_idle_get) { + idle_handler (); } + /* Take the video view's idea of position as our `playhead' and start the + audio stream (which is the timing reference) there. + */ + start_audio_stream_if_open (); + _playing = true; - _dropped = 0; - timer (); - Started (position()); + /* Calling start() below may directly result in Stopped being emitted, and if that + * happens we want it to come after the Started signal, so do that first. + */ + Started (); + _video_view->start (); } + bool FilmViewer::stop () { @@ -436,14 +398,18 @@ FilmViewer::stop () } _playing = false; - Stopped (position()); + _video_view->stop (); + Stopped (); + + _video_view->rethrow (); return true; } + void FilmViewer::player_change (ChangeType type, int property, bool frequent) { - if (type != CHANGE_TYPE_DONE || frequent) { + if (type != ChangeType::DONE || frequent) { return; } @@ -452,41 +418,81 @@ FilmViewer::player_change (ChangeType type, int property, bool frequent) return; } + player_change ({property}); +} + + +void +FilmViewer::player_change (vector properties) +{ calculate_sizes (); - bool refreshed = false; - if ( - property == VideoContentProperty::CROP || - property == VideoContentProperty::SCALE || - property == VideoContentProperty::FADE_IN || - property == VideoContentProperty::FADE_OUT || - property == VideoContentProperty::COLOUR_CONVERSION || - property == PlayerProperty::VIDEO_CONTAINER_SIZE || - property == PlayerProperty::FILM_CONTAINER - ) { - refreshed = quick_refresh (); - } - - if (!refreshed) { + + bool try_quick_refresh = false; + bool update_ccap_tracks = false; + + for (auto i: properties) { + if ( + i == VideoContentProperty::CROP || + i == VideoContentProperty::CUSTOM_RATIO || + i == VideoContentProperty::CUSTOM_SIZE || + i == VideoContentProperty::FADE_IN || + i == VideoContentProperty::FADE_OUT || + i == VideoContentProperty::COLOUR_CONVERSION || + i == PlayerProperty::VIDEO_CONTAINER_SIZE || + i == PlayerProperty::FILM_CONTAINER + ) { + try_quick_refresh = true; + } + + if (i == TextContentProperty::USE || i == TextContentProperty::TYPE || i == TextContentProperty::DCP_TRACK) { + update_ccap_tracks = true; + } + } + + if (!try_quick_refresh || !quick_refresh()) { slow_refresh (); } - PositionChanged (); + + if (update_ccap_tracks) { + _closed_captions_dialog->update_tracks (_film); + } } + void FilmViewer::film_change (ChangeType type, Film::Property p) { - if (type == CHANGE_TYPE_DONE && p == Film::AUDIO_CHANNELS) { + if (type != ChangeType::DONE) { + return; + } + + if (p == Film::Property::AUDIO_CHANNELS) { recreate_butler (); + } else if (p == Film::Property::VIDEO_FRAME_RATE) { + _video_view->set_video_frame_rate (_film->video_frame_rate()); + } else if (p == Film::Property::THREE_D) { + _video_view->set_three_d (_film->three_d()); + } else if (p == Film::Property::CONTENT) { + _closed_captions_dialog->update_tracks (_film); } } + +void +FilmViewer::film_length_change () +{ + _video_view->set_length (_film->length()); +} + + /** Re-get the current frame slowly by seeking */ void FilmViewer::slow_refresh () { - seek (_video_position, true); + seek (_video_view->position(), true); } + /** Try to re-get the current frame quickly by resetting the metadata * in the PlayerVideo that we used last time. * @return true if this was possible, false if not. @@ -494,40 +500,35 @@ FilmViewer::slow_refresh () bool FilmViewer::quick_refresh () { - if (!_player_video.first) { - return false; - } - - if (!_player_video.first->reset_metadata (_film, _player->video_container_size(), _film->frame_size())) { - return false; + if (!_video_view || !_film || !_player) { + return true; } - - display_player_video (); - return true; + return _video_view->reset_metadata (_film, _player->video_container_size()); } + void FilmViewer::seek (shared_ptr content, ContentTime t, bool accurate) { - optional dt = _player->content_time_to_dcp (content, t); + auto dt = _player->content_time_to_dcp (content, t); if (dt) { seek (*dt, accurate); } } + void FilmViewer::set_coalesce_player_changes (bool c) { _coalesce_player_changes = c; if (!c) { - BOOST_FOREACH (int i, _pending_player_changes) { - player_change (CHANGE_TYPE_DONE, i, false); - } + player_change (_pending_player_changes); _pending_player_changes.clear (); } } + void FilmViewer::seek (DCPTime t, bool accurate) { @@ -535,36 +536,42 @@ FilmViewer::seek (DCPTime t, bool accurate) return; } - if (t < DCPTime ()) { + if (t < DCPTime()) { t = DCPTime (); } - if (t >= _film->length ()) { - t = _film->length (); + if (t >= _film->length()) { + t = _film->length() - one_video_frame(); } - bool const was_running = stop (); + suspend (); _closed_captions_dialog->clear (); _butler->seek (t, accurate); - get (); - if (was_running) { - start (); + if (!_playing) { + /* We're not playing, so let the GUI thread get on and + come back later to get the next frame after the seek. + */ + request_idle_display_next_frame (); + } else { + /* We're going to start playing again straight away + so wait for the seek to finish. + */ + while (_video_view->display_next_frame(false) == VideoView::AGAIN) {} } - PositionChanged (); + resume (); } + void FilmViewer::config_changed (Config::Property p) { -#ifdef DCPOMATIC_VARIANT_SWAROOP - if (p == Config::PLAYER_BACKGROUND_IMAGE) { - refresh_panel (); + if (p == Config::AUDIO_MAPPING) { + recreate_butler (); return; } -#endif if (p != Config::SOUND && p != Config::SOUND_OUTPUT) { return; @@ -578,8 +585,12 @@ FilmViewer::config_changed (Config::Property p) unsigned int st = 0; if (Config::instance()->sound_output()) { while (st < _audio.getDeviceCount()) { - if (_audio.getDeviceInfo(st).name == Config::instance()->sound_output().get()) { - break; + try { + if (_audio.getDeviceInfo(st).name == Config::instance()->sound_output().get()) { + break; + } + } catch (RtAudioError&) { + /* Something went wrong with that device so we don't want to use it anyway */ } ++st; } @@ -590,19 +601,15 @@ FilmViewer::config_changed (Config::Property p) st = _audio.getDefaultOutputDevice(); } - _audio_channels = _audio.getDeviceInfo(st).outputChannels; - - RtAudio::StreamParameters sp; - sp.deviceId = st; - sp.nChannels = _audio_channels; - sp.firstChannel = 0; try { + _audio_channels = _audio.getDeviceInfo(st).outputChannels; + RtAudio::StreamParameters sp; + sp.deviceId = st; + sp.nChannels = _audio_channels; + sp.firstChannel = 0; _audio.openStream (&sp, 0, RTAUDIO_FLOAT32, 48000, &_audio_block_size, &rtaudio_callback, this); -#ifdef DCPOMATIC_USE_RTERROR - } catch (RtError& e) { -#else } catch (RtAudioError& e) { -#endif + _audio_channels = 0; error_dialog ( _video_view->get(), _("Could not set up audio output. There will be no audio during the preview."), std_to_wx(e.what()) @@ -616,32 +623,42 @@ FilmViewer::config_changed (Config::Property p) } } + DCPTime FilmViewer::uncorrected_time () const { - if (_audio.isStreamRunning ()) { + if (_audio.isStreamRunning()) { return DCPTime::from_seconds (const_cast(&_audio)->getStreamTime()); } - return _video_position; + return _video_view->position(); } -DCPTime -FilmViewer::time () const + +optional +FilmViewer::audio_time () const { - if (_audio.isStreamRunning ()) { - return DCPTime::from_seconds (const_cast(&_audio)->getStreamTime ()) - - DCPTime::from_frames (average_latency(), _film->audio_frame_rate()); + if (!_audio.isStreamRunning()) { + return {}; } - return _video_position; + return DCPTime::from_seconds (const_cast(&_audio)->getStreamTime ()) - + DCPTime::from_frames (average_latency(), _film->audio_frame_rate()); +} + + +DCPTime +FilmViewer::time () const +{ + return audio_time().get_value_or(_video_view->position()); } + int FilmViewer::audio_callback (void* out_p, unsigned int frames) { while (true) { - optional t = _butler->get_audio (reinterpret_cast (out_p), frames); + auto t = _butler->get_audio (Butler::Behaviour::NON_BLOCKING, reinterpret_cast (out_p), frames); if (!t || DCPTime(uncorrected_time() - *t) < one_video_frame()) { /* There was an underrun or this audio is on time; carry on */ break; @@ -660,6 +677,7 @@ FilmViewer::audio_callback (void* out_p, unsigned int frames) return 0; } + Frame FilmViewer::average_latency () const { @@ -669,13 +687,14 @@ FilmViewer::average_latency () const } Frame total = 0; - BOOST_FOREACH (Frame i, _latency_history) { + for (auto i: _latency_history) { total += i; } return total / _latency_history.size(); } + void FilmViewer::set_dcp_decode_reduction (optional reduction) { @@ -685,18 +704,28 @@ FilmViewer::set_dcp_decode_reduction (optional reduction) } } + optional FilmViewer::dcp_decode_reduction () const { return _dcp_decode_reduction; } + +optional +FilmViewer::position_in_content (shared_ptr content) const +{ + return _player->dcp_to_content_time (content, position()); +} + + DCPTime FilmViewer::one_video_frame () const { - return DCPTime::from_frames (1, _film->video_frame_rate()); + return DCPTime::from_frames (1, _film ? _film->video_frame_rate() : 24); } + /** Open a dialog box showing our film's closed captions */ void FilmViewer::show_closed_captions () @@ -704,14 +733,90 @@ FilmViewer::show_closed_captions () _closed_captions_dialog->Show(); } + void FilmViewer::seek_by (DCPTime by, bool accurate) { - seek (_video_position + by, accurate); + seek (_video_view->position() + by, accurate); } + void FilmViewer::set_pad_black (bool p) { _pad_black = p; } + + +/** Called when a player has finished the current film. + * May be called from a non-UI thread. + */ +void +FilmViewer::finished () +{ + emit (boost::bind(&FilmViewer::ui_finished, this)); +} + + +/** Called by finished() in the UI thread */ +void +FilmViewer::ui_finished () +{ + stop (); + Finished (); +} + + +int +FilmViewer::dropped () const +{ + return _video_view->dropped (); +} + + +int +FilmViewer::errored () const +{ + return _video_view->errored (); +} + + +int +FilmViewer::gets () const +{ + return _video_view->gets (); +} + + +void +FilmViewer::image_changed (shared_ptr pv) +{ + emit (boost::bind(boost::ref(ImageChanged), pv)); +} + + +void +FilmViewer::set_optimise_for_j2k (bool o) +{ + _optimise_for_j2k = o; + _video_view->set_optimise_for_j2k (o); +} + + +void +FilmViewer::set_crop_guess (dcpomatic::Rect crop) +{ + if (crop != _crop_guess) { + _crop_guess = crop; + _video_view->update (); + } +} + + +void +FilmViewer::unset_crop_guess () +{ + _crop_guess = {}; + _video_view->update (); +} +