/*
- Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
This file is part of DCP-o-matic.
*/
+
/** @file src/film_viewer.cc
* @brief A wx widget to view a preview of a Film.
*/
-#include "film_viewer.h"
-#include "playhead_to_timecode_dialog.h"
-#include "playhead_to_frame_dialog.h"
-#include "wx_util.h"
+
#include "closed_captions_dialog.h"
+#include "film_viewer.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 "lib/film.h"
#include "lib/ratio.h"
#include "lib/util.h"
#include <iostream>
#include <iomanip>
-using std::string;
-using std::pair;
-using std::min;
-using std::max;
+
+using std::bad_alloc;
using std::cout;
+using std::dynamic_pointer_cast;
+using std::exception;
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::make_shared;
+using std::max;
+using std::min;
+using std::pair;
+using std::shared_ptr;
+using std::string;
+using std::vector;
+using std::weak_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using dcp::Size;
using namespace dcpomatic;
+
static
int
rtaudio_callback (void* out, void *, unsigned int frames, double, RtAudioStreamStatus, void* data)
return reinterpret_cast<FilmViewer*>(data)->audio_callback (out, frames);
}
+
FilmViewer::FilmViewer (wxWindow* p)
- : _coalesce_player_changes (false)
- , _audio (DCPOMATIC_RTAUDIO_API)
- , _audio_channels (0)
- , _audio_block_size (1024)
- , _playing (false)
- , _suspended (0)
- , _latency_history_count (0)
+ : _audio (DCPOMATIC_RTAUDIO_API)
, _closed_captions_dialog (new ClosedCaptionsDialog(p, this))
- , _outline_content (false)
- , _pad_black (false)
- , _idle_get (false)
{
switch (Config::instance()->video_view_type()) {
case Config::VIDEO_VIEW_OPENGL:
}
_video_view->Sized.connect (boost::bind(&FilmViewer::video_view_sized, this));
+ _video_view->TooManyDropped.connect (boost::bind(&FilmViewer::too_many_frames_dropped, this));
- set_film (shared_ptr<Film> ());
+ set_film (shared_ptr<Film>());
- _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 ::get() to be called next time we are idle */
void
FilmViewer::request_idle_display_next_frame ()
signal_manager->when_idle (boost::bind(&FilmViewer::idle_handler, this));
}
+
void
FilmViewer::idle_handler ()
{
return;
}
- if (_video_view->display_next_frame(true)) {
- _idle_get = false;
- } else {
+ 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> film)
{
}
try {
- _player.reset (new Player(_film));
+ _player = make_shared<Player>(_film);
_player->set_fast ();
if (_dcp_decode_reduction) {
_player->set_dcp_decode_reduction (_dcp_decode_reduction);
_player->set_play_referenced ();
_film->Change.connect (boost::bind (&FilmViewer::film_change, this, _1, _2));
- _film->ContentChange.connect (boost::bind(&FilmViewer::content_change, this, _1, _3));
_film->LengthChange.connect (boost::bind(&FilmViewer::film_length_change, this));
_player->Change.connect (boost::bind (&FilmViewer::player_change, this, _1, _2, _3));
- film_change (CHANGE_TYPE_DONE, Film::VIDEO_FRAME_RATE);
- film_change (CHANGE_TYPE_DONE, Film::THREE_D);
+ 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 */
slow_refresh ();
}
+
void
FilmViewer::recreate_butler ()
{
return;
}
- _butler.reset(
- new Butler(
- _player,
- Config::instance()->audio_mapping(_audio_channels),
- _audio_channels,
- bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24),
- VIDEO_RANGE_FULL,
- false,
- true
- )
+ _butler = std::make_shared<Butler>(
+ _film,
+ _player,
+ Config::instance()->audio_mapping(_audio_channels),
+ _audio_channels,
+ bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24),
+ VideoRange::FULL,
+ false,
+ true
);
if (!Config::instance()->sound() && !_audio.isStreamOpen()) {
resume ();
}
+
void
FilmViewer::set_outline_content (bool o)
{
void
-FilmViewer::set_outline_subtitles (optional<dcpomatic::Rect<double> > rect)
+FilmViewer::set_outline_subtitles (optional<dcpomatic::Rect<double>> rect)
{
_outline_subtitles = rect;
_video_view->update ();
slow_refresh ();
}
+
void
FilmViewer::video_view_sized ()
{
}
}
+
void
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 view_ratio = float(_video_view->get()->GetSize().x) / _video_view->get()->GetSize().y;
+ auto const film_ratio = container ? container->ratio () : 1.78;
if (view_ratio < film_ratio) {
/* panel is less widscreen than the film; clamp width */
_player->set_video_container_size (_out_size);
}
+
void
FilmViewer::suspend ()
{
}
}
+
void
FilmViewer::resume ()
{
}
}
+
void
FilmViewer::start ()
{
return;
}
- optional<bool> v = PlaybackPermitted ();
+ auto v = PlaybackPermitted ();
if (v && !*v) {
/* Computer says no */
return;
*/
if (_audio.isStreamOpen()) {
_audio.setStreamTime (_video_view->position().seconds());
- _audio.startStream ();
+ 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())
+ );
+ }
}
_playing = true;
- _video_view->start ();
+ /* 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 (position());
+ _video_view->start ();
}
+
bool
FilmViewer::stop ()
{
return true;
}
+
void
FilmViewer::player_change (ChangeType type, int property, bool frequent)
{
- if (type != CHANGE_TYPE_DONE || frequent) {
+ if (type != ChangeType::DONE || frequent) {
return;
}
return;
}
+ player_change ({property});
+}
+
+
+void
+FilmViewer::player_change (vector<int> 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::SCALE ||
+ 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 ();
}
+
+ if (update_ccap_tracks) {
+ _closed_captions_dialog->update_tracks (_film);
+ }
}
+
void
FilmViewer::film_change (ChangeType type, Film::Property p)
{
- if (type != CHANGE_TYPE_DONE) {
+ if (type != ChangeType::DONE) {
return;
}
- if (p == Film::AUDIO_CHANNELS) {
+ if (p == Film::Property::AUDIO_CHANNELS) {
recreate_butler ();
- } else if (p == Film::VIDEO_FRAME_RATE) {
+ } else if (p == Film::Property::VIDEO_FRAME_RATE) {
_video_view->set_video_frame_rate (_film->video_frame_rate());
- } else if (p == Film::THREE_D) {
+ } else if (p == Film::Property::THREE_D) {
_video_view->set_three_d (_film->three_d());
- } else if (p == Film::CONTENT) {
+ } 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_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.
if (!_video_view || !_film || !_player) {
return true;
}
- return _video_view->refresh_metadata (_film, _player->video_container_size(), _film->frame_size());
+ return _video_view->reset_metadata (_film, _player->video_container_size());
}
+
void
FilmViewer::seek (shared_ptr<Content> content, ContentTime t, bool accurate)
{
- optional<DCPTime> 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)
{
return;
}
- if (t < DCPTime ()) {
+ if (t < DCPTime()) {
t = DCPTime ();
}
- if (t >= _film->length ()) {
+ if (t >= _film->length()) {
t = _film->length() - one_video_frame();
}
/* We're going to start playing again straight away
so wait for the seek to finish.
*/
- while (!_video_view->display_next_frame(false)) {}
+ while (_video_view->display_next_frame(false) == VideoView::AGAIN) {}
}
resume ();
}
+
void
FilmViewer::config_changed (Config::Property p)
{
}
}
+
DCPTime
FilmViewer::uncorrected_time () const
{
- if (_audio.isStreamRunning ()) {
+ if (_audio.isStreamRunning()) {
return DCPTime::from_seconds (const_cast<RtAudio*>(&_audio)->getStreamTime());
}
return _video_view->position();
}
+
optional<DCPTime>
FilmViewer::audio_time () const
{
if (!_audio.isStreamRunning()) {
- return optional<DCPTime>();
+ return {};
}
return DCPTime::from_seconds (const_cast<RtAudio*>(&_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<DCPTime> t = _butler->get_audio (reinterpret_cast<float*> (out_p), frames);
+ auto t = _butler->get_audio (reinterpret_cast<float*> (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;
return 0;
}
+
Frame
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<int> reduction)
{
}
}
+
optional<int>
FilmViewer::dcp_decode_reduction () const
{
return _dcp_decode_reduction;
}
+
DCPTime
FilmViewer::one_video_frame () const
{
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 ()
_closed_captions_dialog->Show();
}
+
void
FilmViewer::seek_by (DCPTime by, bool 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.
*/
emit (boost::bind(&FilmViewer::ui_finished, this));
}
+
/** Called by finished() in the UI thread */
void
FilmViewer::ui_finished ()
Finished ();
}
+
int
FilmViewer::dropped () const
{
void
-FilmViewer::content_change (ChangeType type, int property)
+FilmViewer::image_changed (shared_ptr<PlayerVideo> pv)
{
- if (type != CHANGE_TYPE_DONE) {
- return;
- }
-
- if (property == TextContentProperty::USE || property == TextContentProperty::TYPE || property == TextContentProperty::DCP_TRACK) {
- _closed_captions_dialog->update_tracks (_film);
- }
+ emit (boost::bind(boost::ref(ImageChanged), pv));
}
void
-FilmViewer::image_changed (shared_ptr<PlayerVideo> pv)
+FilmViewer::too_many_frames_dropped ()
{
- emit (boost::bind(boost::ref(ImageChanged), pv));
-}
+ if (!Config::instance()->nagged(Config::NAG_TOO_MANY_DROPPED_FRAMES)) {
+ stop ();
+ }
+ NagDialog::maybe_nag (
+ panel(),
+ Config::NAG_TOO_MANY_DROPPED_FRAMES,
+ _("The player is dropping a lot of frames, so playback may not be accurate.\n\n"
+ "<b>This does not necessarily mean that the DCP you are playing is defective!</b>\n\n"
+ "You may be able to improve player performance by:\n"
+ "• choosing 'decode at half resolution' or 'decode at quarter resolution' from the View menu\n"
+ "• using a more powerful computer.\n"
+ )
+ );
+}