+2014-05-21 Carl Hetherington <cth@carlh.net>
+
+ * Tidy up logging a bit and make it configurable from the GUI
+ (moving a few things into an Advanced preferences tab at
+ the same time).
+
2014-05-19 Carl Hetherington <cth@carlh.net>
* Version 1.69.9 released.
, _check_for_updates (false)
, _check_for_test_updates (false)
, _maximum_j2k_bandwidth (250000000)
+ , _log_types (Log::GENERAL | Log::WARNING | Log::ERROR)
{
_allowed_dcp_frame_rates.push_back (24);
_allowed_dcp_frame_rates.push_back (25);
_maximum_j2k_bandwidth = f.optional_number_child<int> ("MaximumJ2KBandwidth").get_value_or (250000000);
_allow_any_dcp_frame_rate = f.optional_bool_child ("AllowAnyDCPFrameRate");
+
+ _log_types = f.optional_number_child<int> ("LogTypes").get_value_or (Log::GENERAL | Log::WARNING | Log::ERROR);
}
void
root->add_child("MaximumJ2KBandwidth")->add_child_text (raw_convert<string> (_maximum_j2k_bandwidth));
root->add_child("AllowAnyDCPFrameRate")->add_child_text (_allow_any_dcp_frame_rate ? "1" : "0");
+ root->add_child("LogTypes")->add_child_text (raw_convert<string> (_log_types));
doc.write_to_file_formatted (file(false).string ());
}
int maximum_j2k_bandwidth () const {
return _maximum_j2k_bandwidth;
}
+
+ int log_types () const {
+ return _log_types;
+ }
/** @param n New number of local encoding threads */
void set_num_local_encoding_threads (int n) {
_maximum_j2k_bandwidth = b;
changed ();
}
+
+ void set_log_types (int t) {
+ _log_types = t;
+ changed ();
+ }
boost::filesystem::path signer_chain_directory () const;
bool _check_for_test_updates;
/** maximum allowed J2K bandwidth in bits per second */
int _maximum_j2k_bandwidth;
+ int _log_types;
/** Singleton instance, or 0 */
static Config* _instance;
#endif
#include "exceptions.h"
+#include "i18n.h"
+
+#define LOG_GENERAL(...) log->log (String::compose (__VA_ARGS__), Log::GENERAL);
+#define LOG_ERROR(...) log->log (String::compose (__VA_ARGS__), Log::ERROR);
+
using std::pair;
using std::list;
using std::ifstream;
PROCESS_INFORMATION process_info;
ZeroMemory (&process_info, sizeof (process_info));
if (!CreateProcess (0, command, 0, 0, TRUE, CREATE_NO_WINDOW, 0, 0, &startup_info, &process_info)) {
- log->log ("ffprobe call failed (could not CreateProcess)");
+ LOG_ERROR (N_("ffprobe call failed (could not CreateProcess)"));
return;
}
FILE* o = fopen_boost (out, "w");
if (!o) {
- log->log ("ffprobe call failed (could not create output file)");
+ LOG_ERROR (N_("ffprobe call failed (could not create output file)"));
return;
}
#ifdef DCPOMATIC_LINUX
string ffprobe = "ffprobe \"" + content.string() + "\" 2> \"" + out.string() + "\"";
- log->log (String::compose ("Probing with %1", ffprobe));
+ LOG_GENERAL (N_("Probing with %1"), ffprobe);
system (ffprobe.c_str ());
#endif
path /= "ffprobe";
string ffprobe = path.string() + " \"" + content.string() + "\" 2> \"" + out.string() + "\"";
- log->log (String::compose ("Probing with %1", ffprobe));
+ LOG_GENERAL (N_("Probing with %1"), ffprobe);
system (ffprobe.c_str ());
#endif
}
#include "cross.h"
#include "player_video_frame.h"
+#define LOG_GENERAL(...) _log->log (String::compose (__VA_ARGS__), Log::GENERAL);
+
#include "i18n.h"
using std::string;
switch (_frame->eyes()) {
case EYES_BOTH:
- _log->log (String::compose (N_("Finished locally-encoded frame %1 for mono"), _index));
+ LOG_GENERAL (N_("Finished locally-encoded frame %1 for mono"), _index);
break;
case EYES_LEFT:
- _log->log (String::compose (N_("Finished locally-encoded frame %1 for L"), _index));
+ LOG_GENERAL (N_("Finished locally-encoded frame %1 for L"), _index);
break;
case EYES_RIGHT:
- _log->log (String::compose (N_("Finished locally-encoded frame %1 for R"), _index));
+ LOG_GENERAL (N_("Finished locally-encoded frame %1 for R"), _index);
break;
default:
break;
root->add_child("Version")->add_child_text (raw_convert<string> (SERVER_LINK_VERSION));
add_metadata (root);
- _log->log (String::compose (N_("Sending frame %1 to remote"), _index));
+ LOG_GENERAL (N_("Sending frame %1 to remote"), _index);
/* Send XML metadata */
stringstream xml;
shared_ptr<EncodedData> e (new RemotelyEncodedData (socket->read_uint32 ()));
socket->read (e->data(), e->size());
- _log->log (String::compose (N_("Finished remotely-encoded frame %1"), _index));
+ LOG_GENERAL (N_("Finished remotely-encoded frame %1"), _index);
return e;
}
#include "i18n.h"
+#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), Log::GENERAL);
+#define LOG_ERROR(...) _film->log()->log (String::compose (__VA_ARGS__), Log::ERROR);
+#define LOG_TIMING(...) _film->log()->log (String::compose (__VA_ARGS__), Log::TIMING);
+
using std::pair;
using std::string;
using std::stringstream;
void
Encoder::add_worker_threads (ServerDescription d)
{
- _film->log()->log (String::compose (N_("Adding %1 worker threads for remote %2"), d.host_name ()));
+ LOG_GENERAL (N_("Adding %1 worker threads for remote %2"), d.host_name ());
for (int i = 0; i < d.threads(); ++i) {
_threads.push_back (new boost::thread (boost::bind (&Encoder::encoder_thread, this, d)));
}
{
boost::mutex::scoped_lock lock (_mutex);
- _film->log()->log (String::compose (N_("Clearing queue of %1"), _queue.size ()));
+ LOG_GENERAL (N_("Clearing queue of %1"), _queue.size ());
/* Keep waking workers until the queue is empty */
while (!_queue.empty ()) {
- _film->log()->log (String::compose (N_("Waking with %1"), _queue.size ()), Log::VERBOSE);
_condition.notify_all ();
_condition.wait (lock);
}
terminate_threads ();
- _film->log()->log (String::compose (N_("Mopping up %1"), _queue.size()));
+ LOG_GENERAL (N_("Mopping up %1"), _queue.size());
/* The following sequence of events can occur in the above code:
1. a remote worker takes the last image off the queue
*/
for (list<shared_ptr<DCPVideoFrame> >::iterator i = _queue.begin(); i != _queue.end(); ++i) {
- _film->log()->log (String::compose (N_("Encode left-over frame %1"), (*i)->index ()));
+ LOG_GENERAL (N_("Encode left-over frame %1"), (*i)->index ());
try {
_writer->write ((*i)->encode_locally(), (*i)->index (), (*i)->eyes ());
frame_done ();
} catch (std::exception& e) {
- _film->log()->log (String::compose (N_("Local encode failed (%1)"), e.what ()));
+ LOG_ERROR (N_("Local encode failed (%1)"), e.what ());
}
}
/* Wait until the queue has gone down a bit */
while (_queue.size() >= _threads.size() * 2 && !_terminate) {
- TIMING ("decoder sleeps with queue of %1", _queue.size());
+ LOG_TIMING ("decoder sleeps with queue of %1", _queue.size());
_condition.wait (lock);
- TIMING ("decoder wakes with queue of %1", _queue.size());
+ LOG_TIMING ("decoder wakes with queue of %1", _queue.size());
}
if (_terminate) {
frame_done ();
} else {
/* Queue this new frame for encoding */
- TIMING ("adding to queue of %1", _queue.size ());
+ LOG_TIMING ("adding to queue of %1", _queue.size ());
_queue.push_back (shared_ptr<DCPVideoFrame> (
new DCPVideoFrame (
pvf, _video_frames_out, _film->video_frame_rate(),
while (1) {
- TIMING ("encoder thread %1 sleeps", boost::this_thread::get_id());
+ LOG_TIMING ("encoder thread %1 sleeps", boost::this_thread::get_id());
boost::mutex::scoped_lock lock (_mutex);
while (_queue.empty () && !_terminate) {
_condition.wait (lock);
return;
}
- TIMING ("encoder thread %1 wakes with queue of %2", boost::this_thread::get_id(), _queue.size());
+ LOG_TIMING ("encoder thread %1 wakes with queue of %2", boost::this_thread::get_id(), _queue.size());
shared_ptr<DCPVideoFrame> vf = _queue.front ();
- TIMING ("encoder thread %1 pops frame %2 (%3) from queue", boost::this_thread::get_id(), vf->index(), vf->eyes ());
+ LOG_TIMING ("encoder thread %1 pops frame %2 (%3) from queue", boost::this_thread::get_id(), vf->index(), vf->eyes ());
_queue.pop_front ();
lock.unlock ();
encoded = vf->encode_remotely (server.get ());
if (remote_backoff > 0) {
- _film->log()->log (String::compose (N_("%1 was lost, but now she is found; removing backoff"), server->host_name ()));
+ LOG_GENERAL ("%1 was lost, but now she is found; removing backoff", server->host_name ());
}
/* This job succeeded, so remove any backoff */
/* back off more */
remote_backoff += 10;
}
- _film->log()->log (
- String::compose (
- N_("Remote encode of %1 on %2 failed (%3); thread sleeping for %4s"),
- vf->index(), server->host_name(), e.what(), remote_backoff)
+ LOG_ERROR (
+ N_("Remote encode of %1 on %2 failed (%3); thread sleeping for %4s"),
+ vf->index(), server->host_name(), e.what(), remote_backoff
);
}
} else {
try {
- TIMING ("encoder thread %1 begins local encode of %2", boost::this_thread::get_id(), vf->index());
+ LOG_TIMING ("encoder thread %1 begins local encode of %2", boost::this_thread::get_id(), vf->index());
encoded = vf->encode_locally ();
- TIMING ("encoder thread %1 finishes local encode of %2", boost::this_thread::get_id(), vf->index());
+ LOG_TIMING ("encoder thread %1 finishes local encode of %2", boost::this_thread::get_id(), vf->index());
} catch (std::exception& e) {
- _film->log()->log (String::compose (N_("Local encode failed (%1)"), e.what ()));
+ LOG_ERROR (N_("Local encode failed (%1)"), e.what ());
}
}
frame_done ();
} else {
lock.lock ();
- _film->log()->log (
- String::compose (N_("Encoder thread %1 pushes frame %2 back onto queue after failure"), boost::this_thread::get_id(), vf->index())
- );
+ LOG_GENERAL (N_("Encoder thread %1 pushes frame %2 back onto queue after failure"), boost::this_thread::get_id(), vf->index());
_queue.push_front (vf);
lock.unlock ();
}
#include "i18n.h"
+#define LOG_GENERAL(...) film->log()->log (String::compose (__VA_ARGS__), Log::GENERAL);
+
using std::string;
using std::stringstream;
using std::vector;
VideoContent::Frame video_length = 0;
video_length = examiner->video_length ();
- film->log()->log (String::compose ("Video length obtained from header as %1 frames", video_length));
+ LOG_GENERAL ("Video length obtained from header as %1 frames", video_length);
{
boost::mutex::scoped_lock lm (_mutex);
/*
- Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "i18n.h"
+#define LOG_GENERAL(...) film->log()->log (String::compose (__VA_ARGS__), Log::GENERAL);
+#define LOG_ERROR(...) film->log()->log (String::compose (__VA_ARGS__), Log::ERROR);
+#define LOG_WARNING(...) film->log()->log (__VA_ARGS__, Log::WARNING);
+
using std::cout;
using std::string;
using std::vector;
av_strerror (r, buf, sizeof(buf));
shared_ptr<const Film> film = _film.lock ();
assert (film);
- film->log()->log (String::compose (N_("error on av_read_frame (%1) (%2)"), buf, r));
+ LOG_ERROR (N_("error on av_read_frame (%1) (%2)"), buf, r);
}
flush ();
if (decode_result < 0) {
shared_ptr<const Film> film = _film.lock ();
assert (film);
- film->log()->log (String::compose ("avcodec_decode_audio4 failed (%1)", decode_result));
+ LOG_ERROR ("avcodec_decode_audio4 failed (%1)", decode_result);
return;
}
graph.reset (new FilterGraph (_ffmpeg_content, libdcp::Size (_frame->width, _frame->height), (AVPixelFormat) _frame->format));
_filter_graphs.push_back (graph);
- film->log()->log (String::compose (N_("New graph for %1x%2, pixel format %3"), _frame->width, _frame->height, _frame->format));
+ LOG_GENERAL (N_("New graph for %1x%2, pixel format %3"), _frame->width, _frame->height, _frame->format);
} else {
graph = *i;
}
list<pair<shared_ptr<Image>, int64_t> > images = graph->process (_frame);
+ shared_ptr<const Film> film = _film.lock ();
+ assert (film);
+
for (list<pair<shared_ptr<Image>, int64_t> >::iterator i = images.begin(); i != images.end(); ++i) {
shared_ptr<Image> image = i->first;
)
);
+ shared_ptr<const Film> film = _film.lock ();
+ assert (film);
+
black->make_black ();
- video (shared_ptr<ImageProxy> (new RawImageProxy (image)), false, _video_position);
+ video (shared_ptr<ImageProxy> (new RawImageProxy (image, film->log())), false, _video_position);
delta -= one_frame;
}
if (delta > -one_frame) {
/* This PTS is within a frame of being right; emit this (otherwise it will be dropped) */
- video (shared_ptr<ImageProxy> (new RawImageProxy (image)), false, _video_position);
+ video (shared_ptr<ImageProxy> (new RawImageProxy (image, film->log())), false, _video_position);
}
} else {
- shared_ptr<const Film> film = _film.lock ();
- assert (film);
- film->log()->log ("Dropping frame without PTS");
+ LOG_WARNING ("Dropping frame without PTS");
}
}
using libdcp::Signer;
using libdcp::raw_convert;
+#define LOG_GENERAL(...) log()->log (String::compose (__VA_ARGS__), Log::GENERAL);
+#define LOG_GENERAL_NC(...) log()->log (__VA_ARGS__, Log::GENERAL);
+
/* 5 -> 6
* AudioMapping XML changed.
* 6 -> 7
*/
write_metadata ();
- log()->log (String::compose ("DCP-o-matic %1 git %2 using %3", dcpomatic_version, dcpomatic_git_commit, dependency_version_summary()));
+ LOG_GENERAL ("DCP-o-matic %1 git %2 using %3", dcpomatic_version, dcpomatic_git_commit, dependency_version_summary());
{
char buffer[128];
gethostname (buffer, sizeof (buffer));
- log()->log (String::compose ("Starting to make DCP on %1", buffer));
+ LOG_GENERAL ("Starting to make DCP on %1", buffer);
}
ContentList cl = content ();
for (ContentList::const_iterator i = cl.begin(); i != cl.end(); ++i) {
- log()->log (String::compose ("Content: %1", (*i)->technical_summary()));
+ LOG_GENERAL ("Content: %1", (*i)->technical_summary());
}
- log()->log (String::compose ("DCP video rate %1 fps", video_frame_rate()));
- log()->log (String::compose ("%1 threads", Config::instance()->num_local_encoding_threads()));
- log()->log (String::compose ("J2K bandwidth %1", j2k_bandwidth()));
+ LOG_GENERAL ("DCP video rate %1 fps", video_frame_rate());
+ LOG_GENERAL ("%1 threads", Config::instance()->num_local_encoding_threads());
+ LOG_GENERAL ("J2K bandwidth %1", j2k_bandwidth());
#ifdef DCPOMATIC_DEBUG
- log()->log ("DCP-o-matic built in debug mode.");
+ LOG_GENERAL_NC ("DCP-o-matic built in debug mode.");
#else
- log()->log ("DCP-o-matic built in optimised mode.");
+ LOG_GENERAL_NC ("DCP-o-matic built in optimised mode.");
#endif
#ifdef LIBDCP_DEBUG
- log()->log ("libdcp built in debug mode.");
+ LOG_GENERAL_NC ("libdcp built in debug mode.");
#else
- log()->log ("libdcp built in optimised mode.");
+ LOG_GENERAL_NC ("libdcp built in optimised mode.");
#endif
#ifdef DCPOMATIC_WINDOWS
OSVERSIONINFO info;
info.dwOSVersionInfoSize = sizeof (info);
GetVersionEx (&info);
- log()->log (String::compose ("Windows version %1.%2.%3 SP %4", info.dwMajorVersion, info.dwMinorVersion, info.dwBuildNumber, info.szCSDVersion));
+ LOG_GENERAL ("Windows version %1.%2.%3 SP %4", info.dwMajorVersion, info.dwMinorVersion, info.dwBuildNumber, info.szCSDVersion);
#endif
- log()->log (String::compose ("CPU: %1, %2 processors", cpu_info(), boost::thread::hardware_concurrency ()));
+ LOG_GENERAL ("CPU: %1, %2 processors", cpu_info(), boost::thread::hardware_concurrency ());
list<pair<string, string> > const m = mount_info ();
for (list<pair<string, string> >::const_iterator i = m.begin(); i != m.end(); ++i) {
- log()->log (String::compose ("Mount: %1 %2", i->first, i->second));
+ LOG_GENERAL ("Mount: %1 %2", i->first, i->second);
}
if (container() == 0) {
return;
}
- _image.reset (new MagickImageProxy (_image_content->path (_image_content->still() ? 0 : _video_position)));
+ shared_ptr<const Film> film = _film.lock ();
+ assert (film);
+
+ _image.reset (new MagickImageProxy (_image_content->path (_image_content->still() ? 0 : _video_position), film->log ()));
video (_image, false, _video_position);
}
#include "image.h"
#include "exceptions.h"
#include "cross.h"
+#include "log.h"
#include "i18n.h"
+#define LOG_TIMING(...) _log->microsecond_log (String::compose (__VA_ARGS__), Log::TIMING);
+
using std::cout;
using std::string;
using std::stringstream;
using boost::shared_ptr;
-RawImageProxy::RawImageProxy (shared_ptr<Image> image)
- : _image (image)
+ImageProxy::ImageProxy (shared_ptr<Log> log)
+ : _log (log)
+{
+
+}
+
+RawImageProxy::RawImageProxy (shared_ptr<Image> image, shared_ptr<Log> log)
+ : ImageProxy (log)
+ , _image (image)
{
}
-RawImageProxy::RawImageProxy (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
+RawImageProxy::RawImageProxy (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket, shared_ptr<Log> log)
+ : ImageProxy (log)
{
libdcp::Size size (
xml->number_child<int> ("Width"), xml->number_child<int> ("Height")
_image->write_to_socket (socket);
}
-MagickImageProxy::MagickImageProxy (boost::filesystem::path path)
+MagickImageProxy::MagickImageProxy (boost::filesystem::path path, shared_ptr<Log> log)
+ : ImageProxy (log)
{
/* Read the file into a Blob */
delete[] data;
}
-MagickImageProxy::MagickImageProxy (shared_ptr<cxml::Node>, shared_ptr<Socket> socket)
+MagickImageProxy::MagickImageProxy (shared_ptr<cxml::Node>, shared_ptr<Socket> socket, shared_ptr<Log> log)
+ : ImageProxy (log)
{
uint32_t const size = socket->read_uint32 ();
uint8_t* data = new uint8_t[size];
return _image;
}
- TIMING("MagickImageProxy begins read and decode of %1 bytes", _blob.length());
+ LOG_TIMING ("MagickImageProxy begins read and decode of %1 bytes", _blob.length());
Magick::Image* magick_image = 0;
try {
delete magick_image;
- TIMING("MagickImageProxy completes read and decode of %1 bytes", _blob.length());
+ LOG_TIMING ("MagickImageProxy completes read and decode of %1 bytes", _blob.length());
return _image;
}
}
shared_ptr<ImageProxy>
-image_proxy_factory (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
+image_proxy_factory (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket, shared_ptr<Log> log)
{
if (xml->string_child("Type") == N_("Raw")) {
- return shared_ptr<ImageProxy> (new RawImageProxy (xml, socket));
+ return shared_ptr<ImageProxy> (new RawImageProxy (xml, socket, log));
} else if (xml->string_child("Type") == N_("Magick")) {
- return shared_ptr<MagickImageProxy> (new MagickImageProxy (xml, socket));
+ return shared_ptr<MagickImageProxy> (new MagickImageProxy (xml, socket, log));
}
throw NetworkError (_("Unexpected image type received by server"));
class Image;
class Socket;
+class Log;
namespace cxml {
class Node;
class ImageProxy
{
public:
+ ImageProxy (boost::shared_ptr<Log> log);
+
virtual boost::shared_ptr<Image> image () const = 0;
virtual void add_metadata (xmlpp::Node *) const = 0;
virtual void send_binary (boost::shared_ptr<Socket>) const = 0;
+
+protected:
+ boost::shared_ptr<Log> _log;
};
class RawImageProxy : public ImageProxy
{
public:
- RawImageProxy (boost::shared_ptr<Image>);
- RawImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+ RawImageProxy (boost::shared_ptr<Image>, boost::shared_ptr<Log> log);
+ RawImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket, boost::shared_ptr<Log> log);
boost::shared_ptr<Image> image () const;
void add_metadata (xmlpp::Node *) const;
class MagickImageProxy : public ImageProxy
{
public:
- MagickImageProxy (boost::filesystem::path);
- MagickImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+ MagickImageProxy (boost::filesystem::path, boost::shared_ptr<Log> log);
+ MagickImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket, boost::shared_ptr<Log> log);
boost::shared_ptr<Image> image () const;
void add_metadata (xmlpp::Node *) const;
mutable boost::shared_ptr<Image> _image;
};
-boost::shared_ptr<ImageProxy> image_proxy_factory (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+boost::shared_ptr<ImageProxy> image_proxy_factory (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket, boost::shared_ptr<Log> log);
#include <time.h>
#include <cstdio>
+#include <boost/algorithm/string.hpp>
#include "log.h"
#include "cross.h"
+#include "config.h"
#include "i18n.h"
using namespace std;
+using boost::algorithm::is_any_of;
+using boost::algorithm::split;
+
+int const Log::GENERAL = 0x1;
+int const Log::WARNING = 0x2;
+int const Log::ERROR = 0x4;
+int const Log::TIMING = 0x8;
Log::Log ()
- : _level (STANDARD)
+ : _types (0)
{
+ Config::instance()->Changed.connect (boost::bind (&Log::config_changed, this));
+ config_changed ();
+}
+void
+Log::config_changed ()
+{
+ set_types (Config::instance()->log_types ());
}
/** @param n String to log */
void
-Log::log (string m, Level l)
+Log::log (string message, int type)
{
boost::mutex::scoped_lock lm (_mutex);
- if (l > _level) {
+ if ((_types & type) == 0) {
return;
}
string a = ctime (&t);
stringstream s;
- s << a.substr (0, a.length() - 1) << N_(": ") << m;
+ s << a.substr (0, a.length() - 1) << N_(": ");
+
+ if (type & ERROR) {
+ s << "ERROR: ";
+ }
+
+ if (type & WARNING) {
+ s << "WARNING: ";
+ }
+
+ s << message;
do_log (s.str ());
}
void
-Log::microsecond_log (string m, Level l)
+Log::microsecond_log (string m, int t)
{
boost::mutex::scoped_lock lm (_mutex);
- if (l > _level) {
+ if ((_types & t) == 0) {
return;
}
}
void
-Log::set_level (Level l)
+Log::set_types (int t)
{
boost::mutex::scoped_lock lm (_mutex);
- _level = l;
+ _types = t;
}
+/** @param A comma-separate list of debug types to enable */
void
-Log::set_level (string l)
+Log::set_types (string t)
{
- if (l == N_("verbose")) {
- set_level (VERBOSE);
- return;
- } else if (l == N_("timing")) {
- set_level (TIMING);
- return;
- }
+ boost::mutex::scoped_lock lm (_mutex);
- set_level (STANDARD);
+ vector<string> types;
+ split (types, t, is_any_of (","));
+
+ _types = 0;
+
+ for (vector<string>::const_iterator i = types.begin(); i != types.end(); ++i) {
+ if (*i == N_("general")) {
+ _types |= GENERAL;
+ } else if (*i == N_("warning")) {
+ _types |= WARNING;
+ } else if (*i == N_("error")) {
+ _types |= ERROR;
+ } else if (*i == N_("timing")) {
+ _types |= TIMING;
+ }
+ }
}
/** @param file Filename to write log to */
Log ();
virtual ~Log () {}
- enum Level {
- STANDARD = 0,
- VERBOSE = 1,
- TIMING = 2
- };
+ static const int GENERAL;
+ static const int WARNING;
+ static const int ERROR;
+ static const int TIMING;
- void log (std::string m, Level l = STANDARD);
- void microsecond_log (std::string m, Level l = STANDARD);
+ void log (std::string message, int type);
+ void microsecond_log (std::string message, int type);
- void set_level (Level l);
- void set_level (std::string l);
+ void set_types (int types);
+ void set_types (std::string types);
protected:
/** mutex to protect the log */
private:
virtual void do_log (std::string m) = 0;
+ void config_changed ();
- /** level above which to ignore log messages */
- Level _level;
+ /** bit-field of log types which should be put into the log (others are ignored) */
+ int _types;
};
class FileLog : public Log
#include "scaler.h"
#include "player_video_frame.h"
+#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), Log::GENERAL);
+
using std::list;
using std::cout;
using std::min;
_black_frame.reset (
new PlayerVideoFrame (
- shared_ptr<ImageProxy> (new RawImageProxy (im)),
+ shared_ptr<ImageProxy> (new RawImageProxy (im, _film->log ())),
Crop(),
_video_container_size,
_video_container_size,
return shared_ptr<Resampler> ();
}
- _film->log()->log (
- String::compose (
- "Creating new resampler for %1 to %2 with %3 channels", c->content_audio_frame_rate(), c->output_audio_frame_rate(), c->audio_channels()
- )
+ LOG_GENERAL (
+ "Creating new resampler for %1 to %2 with %3 channels", c->content_audio_frame_rate(), c->output_audio_frame_rate(), c->audio_channels()
);
shared_ptr<Resampler> r (new Resampler (c->content_audio_frame_rate(), c->output_audio_frame_rate(), c->audio_channels()));
}
-PlayerVideoFrame::PlayerVideoFrame (shared_ptr<cxml::Node> node, shared_ptr<Socket> socket)
+PlayerVideoFrame::PlayerVideoFrame (shared_ptr<cxml::Node> node, shared_ptr<Socket> socket, shared_ptr<Log> log)
{
_crop = Crop (node);
_part = (Part) node->number_child<int> ("Part");
_colour_conversion = ColourConversion (node);
- _in = image_proxy_factory (node->node_child ("In"), socket);
+ _in = image_proxy_factory (node->node_child ("In"), socket, log);
if (node->optional_number_child<int> ("SubtitleX")) {
class ImageProxy;
class Scaler;
class Socket;
+class Log;
/** Everything needed to describe a video frame coming out of the player, but with the
* bits still their raw form. We may want to combine the bits on a remote machine,
{
public:
PlayerVideoFrame (boost::shared_ptr<const ImageProxy>, Crop, libdcp::Size, libdcp::Size, Scaler const *, Eyes, Part, ColourConversion);
- PlayerVideoFrame (boost::shared_ptr<cxml::Node>, boost::shared_ptr<Socket>);
+ PlayerVideoFrame (boost::shared_ptr<cxml::Node>, boost::shared_ptr<Socket>, boost::shared_ptr<Log>);
void set_subtitle (boost::shared_ptr<const Image>, Position<int>);
#include "i18n.h"
+#define LOG_GENERAL_NC(...) _film->log()->microsecond_log (__VA_ARGS__, Log::GENERAL);
+
using std::string;
using std::stringstream;
using std::min;
void
SCPDCPJob::run ()
{
- _film->log()->log (N_("SCP DCP job starting"));
+ LOG_GENERAL_NC (N_("SCP DCP job starting"));
SSHSession ss;
#include "i18n.h"
+#define LOG_GENERAL(...) _log->microsecond_log (String::compose (__VA_ARGS__), Log::GENERAL);
+#define LOG_GENERAL_NC(...) _log->microsecond_log (__VA_ARGS__, Log::GENERAL);
+#define LOG_ERROR(...) _log->microsecond_log (String::compose (__VA_ARGS__), Log::ERROR);
+#define LOG_ERROR_NC(...) _log->microsecond_log (__VA_ARGS__, Log::ERROR);
+
using std::string;
using std::stringstream;
using std::multimap;
xml->read_stream (s);
if (xml->number_child<int> ("Version") != SERVER_LINK_VERSION) {
cerr << "Mismatched server/client versions\n";
- _log->log ("Mismatched server/client versions");
+ LOG_ERROR_NC ("Mismatched server/client versions");
return -1;
}
- shared_ptr<PlayerVideoFrame> pvf (new PlayerVideoFrame (xml, socket));
+ shared_ptr<PlayerVideoFrame> pvf (new PlayerVideoFrame (xml, socket, _log));
DCPVideoFrame dcp_video_frame (pvf, xml, _log);
try {
encoded->send (socket);
} catch (std::exception& e) {
- _log->log (String::compose ("Send failed; frame %1", dcp_video_frame.index()));
+ LOG_ERROR ("Send failed; frame %1", dcp_video_frame.index());
throw;
}
frame = process (socket, after_read, after_encode);
ip = socket->socket().remote_endpoint().address().to_string();
} catch (std::exception& e) {
- _log->log (String::compose ("Error: %1", e.what()));
+ LOG_ERROR ("Error: %1", e.what());
}
gettimeofday (&end, 0);
cout << message.str() << "\n";
}
- _log->log (message.str ());
+ LOG_GENERAL_NC (message.str ());
}
_worker_condition.notify_all ();
void
Server::run (int num_threads)
{
- _log->log (String::compose ("Server starting with %1 threads", num_threads));
+ LOG_GENERAL ("Server starting with %1 threads", num_threads);
if (_verbose) {
cout << "DCP-o-matic server starting with " << num_threads << " threads.\n";
}
#include "i18n.h"
+#define LOG_GENERAL_NC(...) _film->log()->microsecond_log (__VA_ARGS__, Log::GENERAL);
+#define LOG_ERROR_NC(...) _film->log()->microsecond_log (__VA_ARGS__, Log::ERROR);
+
using std::string;
using std::stringstream;
using std::fixed;
{
try {
- _film->log()->log (N_("Transcode job starting"));
+ LOG_GENERAL_NC (N_("Transcode job starting"));
_transcoder.reset (new Transcoder (_film, shared_from_this ()));
_transcoder->go ();
set_progress (1);
set_state (FINISHED_OK);
- _film->log()->log (N_("Transcode job completed successfully"));
+ LOG_GENERAL_NC (N_("Transcode job completed successfully"));
_transcoder.reset ();
} catch (...) {
set_progress (1);
set_state (FINISHED_ERROR);
- _film->log()->log (N_("Transcode job failed or cancelled"));
+ LOG_ERROR_NC (N_("Transcode job failed or cancelled"));
_transcoder.reset ();
throw;
}
#include "types.h"
#include "video_content.h"
-#ifdef DCPOMATIC_DEBUG
-#define TIMING(...) _film->log()->microsecond_log (String::compose (__VA_ARGS__), Log::TIMING);
-#else
-#define TIMING(...)
-#endif
-
#undef check
/** The maximum number of audio channels that we can have in a DCP */
#include "i18n.h"
+#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), Log::GENERAL);
+#define LOG_TIMING(...) _film->log()->microsecond_log (String::compose (__VA_ARGS__), Log::TIMING);
+#define LOG_WARNING_NC(...) _film->log()->log (__VA_ARGS__, Log::WARNING);
+
/* OS X strikes again */
#undef set_key
break;
}
- TIMING (N_("writer sleeps with a queue of %1"), _queue.size());
+ LOG_TIMING (N_("writer sleeps with a queue of %1"), _queue.size());
_empty_condition.wait (lock);
- TIMING (N_("writer wakes with a queue of %1"), _queue.size());
+ LOG_TIMING (N_("writer wakes with a queue of %1"), _queue.size());
}
if (_finish && _queue.empty()) {
switch (qi.type) {
case QueueItem::FULL:
{
- _film->log()->log (String::compose (N_("Writer FULL-writes %1 to MXF"), qi.frame));
+ LOG_GENERAL (N_("Writer FULL-writes %1 to MXF"), qi.frame);
if (!qi.encoded) {
qi.encoded.reset (new EncodedData (_film->j2c_path (qi.frame, qi.eyes, false)));
}
break;
}
case QueueItem::FAKE:
- _film->log()->log (String::compose (N_("Writer FAKE-writes %1 to MXF"), qi.frame));
+ LOG_GENERAL (N_("Writer FAKE-writes %1 to MXF"), qi.frame);
_picture_asset_writer->fake_write (qi.size);
_last_written[qi.eyes].reset ();
++_fake_written;
break;
case QueueItem::REPEAT:
{
- _film->log()->log (String::compose (N_("Writer REPEAT-writes %1 to MXF"), qi.frame));
+ LOG_GENERAL (N_("Writer REPEAT-writes %1 to MXF"), qi.frame);
libdcp::FrameInfo fin = _picture_asset_writer->write (
_last_written[qi.eyes]->data(),
_last_written[qi.eyes]->size()
lock.unlock ();
- _film->log()->log (
- String::compose (
- "Writer full (awaiting %1 [last eye was %2]); pushes %3 to disk",
- _last_written_frame + 1,
- _last_written_eyes, qi.frame)
+ LOG_GENERAL (
+ "Writer full (awaiting %1 [last eye was %2]); pushes %3 to disk",
+ _last_written_frame + 1,
+ _last_written_eyes, qi.frame
);
qi.encoded->write (_film, qi.frame, qi.eyes);
if (ec) {
/* hard link failed; copy instead */
boost::filesystem::copy_file (video_from, video_to);
- _film->log()->log ("Hard-link failed; fell back to copying");
+ LOG_WARNING_NC ("Hard-link failed; fell back to copying");
}
/* And update the asset */
meta.set_issue_date_now ();
dcp.write_xml (_film->interop (), meta, _film->is_signed() ? make_signer () : shared_ptr<const libdcp::Signer> ());
- _film->log()->log (
- String::compose (N_("Wrote %1 FULL, %2 FAKE, %3 REPEAT; %4 pushed to disk"), _full_written, _fake_written, _repeat_written, _pushed_to_disk)
+ LOG_GENERAL (
+ N_("Wrote %1 FULL, %2 FAKE, %3 REPEAT; %4 pushed to disk"), _full_written, _fake_written, _repeat_written, _pushed_to_disk
);
}
/* Read the frame info as written */
FILE* ifi = fopen_boost (_film->info_path (f, eyes), "r");
if (!ifi) {
- _film->log()->log (String::compose ("Existing frame %1 has no info file", f));
+ LOG_GENERAL ("Existing frame %1 has no info file", f);
return false;
}
libdcp::FrameInfo info (ifi);
fclose (ifi);
if (info.size == 0) {
- _film->log()->log (String::compose ("Existing frame %1 has no info file", f));
+ LOG_GENERAL ("Existing frame %1 has no info file", f);
return false;
}
EncodedData data (info.size);
size_t const read = fread (data.data(), 1, data.size(), mxf);
if (read != static_cast<size_t> (data.size ())) {
- _film->log()->log (String::compose ("Existing frame %1 is incomplete", f));
+ LOG_GENERAL ("Existing frame %1 is incomplete", f);
return false;
}
string const existing_hash = md5_digest (data.data(), data.size());
if (existing_hash != info.hash) {
- _film->log()->log (String::compose ("Existing frame %1 failed hash check", f));
+ LOG_GENERAL ("Existing frame %1 failed hash check", f);
return false;
}
p /= _film->internal_video_mxf_filename ();
FILE* mxf = fopen_boost (p, "rb");
if (!mxf) {
- _film->log()->log (String::compose ("Could not open existing MXF at %1 (errno=%2)", p.string(), errno));
+ LOG_GENERAL ("Could not open existing MXF at %1 (errno=%2)", p.string(), errno);
return;
}
}
}
- _film->log()->log (String::compose ("Have existing frame %1", _first_nonexistant_frame));
+ LOG_GENERAL ("Have existing frame %1", _first_nonexistant_frame);
++_first_nonexistant_frame;
}
static FilmEditor* film_editor = 0;
static FilmViewer* film_viewer = 0;
static shared_ptr<Film> film;
-static std::string log_level;
+static std::string log_types = "general,log,warning";
static std::string film_to_load;
static std::string film_to_create;
static std::string content_to_add;
for (list<string>::const_iterator i = notes.begin(); i != notes.end(); ++i) {
error_dialog (0, std_to_wx (*i));
}
- film->log()->set_level (log_level);
+ film->log()->set_types (log_types);
}
#define ALWAYS 0x0
maybe_save_then_delete_film ();
film.reset (new Film (d->get_path ()));
film->write_metadata ();
- film->log()->set_level (log_level);
+ film->log()->set_types (log_types);
film->set_name (boost::filesystem::path (d->get_path()).filename().generic_string());
set_film ();
}
};
static const wxCmdLineEntryDesc command_line_description[] = {
- { wxCMD_LINE_OPTION, "l", "log", "set log level (silent, verbose or timing)", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
+ { wxCMD_LINE_OPTION, "l", "log", "set message types to log (general,warning,error,timing)", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
{ wxCMD_LINE_SWITCH, "n", "new", "create new film", wxCMD_LINE_VAL_NONE, wxCMD_LINE_PARAM_OPTIONAL },
{ wxCMD_LINE_OPTION, "c", "content", "add content file", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
{ wxCMD_LINE_PARAM, 0, 0, "film to load or create", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
if (!film_to_create.empty ()) {
film.reset (new Film (film_to_create));
film->write_metadata ();
- film->log()->set_level (log_level);
+ film->log()->set_types (log_types);
film->set_name (boost::filesystem::path (film_to_create).filename().generic_string ());
}
wxString log;
if (parser.Found (wxT ("log"), &log)) {
- log_level = wx_to_std (log);
+ log_types = wx_to_std (log);
}
return true;
string film_dir;
bool progress = true;
bool no_remote = false;
- int log_level = 0;
+ string log_types = "general,warning,error";
int json_port = 0;
bool keep_going = false;
{ "flags", no_argument, 0, 'f'},
{ "no-progress", no_argument, 0, 'n'},
{ "no-remote", no_argument, 0, 'r'},
- { "log-level", required_argument, 0, 'l' },
+ { "log-types", required_argument, 0, 'l' },
{ "json", required_argument, 0, 'j' },
{ "keep-going", no_argument, 0, 'k' },
{ 0, 0, 0, 0 }
no_remote = true;
break;
case 'l':
- log_level = atoi (optarg);
+ log_types = optarg;
break;
case 'j':
json_port = atoi (optarg);
exit (EXIT_FAILURE);
}
- film->log()->set_level ((Log::Level) log_level);
+ film->log()->set_types (log_types);
cout << "\nMaking DCP for " << film->name() << "\n";
// cout << "Content: " << film->content() << "\n";
_num_local_encoding_threads = new wxSpinCtrl (panel);
table->Add (_num_local_encoding_threads, 1);
- add_label_to_sizer (table, panel, _("Maximum JPEG2000 bandwidth"), true);
- _maximum_j2k_bandwidth = new wxSpinCtrl (panel);
- table->Add (_maximum_j2k_bandwidth, 1);
-
- _allow_any_dcp_frame_rate = new wxCheckBox (panel, wxID_ANY, _("Allow any DCP frame rate"));
- table->Add (_allow_any_dcp_frame_rate, 1, wxEXPAND | wxALL);
- table->AddSpacer (0);
-
add_label_to_sizer (table, panel, _("Outgoing mail server"), true);
_mail_server = new wxTextCtrl (panel, wxID_ANY);
table->Add (_mail_server, 1, wxEXPAND | wxALL);
_num_local_encoding_threads->SetValue (config->num_local_encoding_threads ());
_num_local_encoding_threads->Bind (wxEVT_COMMAND_SPINCTRL_UPDATED, boost::bind (&GeneralPage::num_local_encoding_threads_changed, this));
- _maximum_j2k_bandwidth->SetRange (1, 500);
- _maximum_j2k_bandwidth->SetValue (config->maximum_j2k_bandwidth() / 1000000);
- _maximum_j2k_bandwidth->Bind (wxEVT_COMMAND_SPINCTRL_UPDATED, boost::bind (&GeneralPage::maximum_j2k_bandwidth_changed, this));
-
_mail_server->SetValue (std_to_wx (config->mail_server ()));
_mail_server->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&GeneralPage::mail_server_changed, this));
_mail_user->SetValue (std_to_wx (config->mail_user ()));
_check_for_updates->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&GeneralPage::check_for_updates_changed, this));
_check_for_test_updates->SetValue (config->check_for_test_updates ());
_check_for_test_updates->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&GeneralPage::check_for_test_updates_changed, this));
- _allow_any_dcp_frame_rate->SetValue (config->allow_any_dcp_frame_rate ());
- _allow_any_dcp_frame_rate->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&GeneralPage::allow_any_dcp_frame_rate_changed, this));
return panel;
}
Config::instance()->set_num_local_encoding_threads (_num_local_encoding_threads->GetValue ());
}
- void maximum_j2k_bandwidth_changed ()
- {
- Config::instance()->set_maximum_j2k_bandwidth (_maximum_j2k_bandwidth->GetValue() * 1000000);
- }
-
- void allow_any_dcp_frame_rate_changed ()
- {
- Config::instance()->set_allow_any_dcp_frame_rate (_allow_any_dcp_frame_rate->GetValue ());
- }
-
wxCheckBox* _set_language;
wxChoice* _language;
wxSpinCtrl* _num_local_encoding_threads;
- wxSpinCtrl* _maximum_j2k_bandwidth;
- wxCheckBox* _allow_any_dcp_frame_rate;
wxTextCtrl* _mail_server;
wxTextCtrl* _mail_user;
wxTextCtrl* _mail_password;
wxTextCtrl* _kdm_email;
};
+class AdvancedPage : public wxStockPreferencesPage, public Page
+{
+public:
+
+ AdvancedPage (wxSize panel_size, int border)
+ : wxStockPreferencesPage (Kind_Advanced)
+ , Page (panel_size, border)
+ {}
+
+ wxWindow* CreateWindow (wxWindow* parent)
+ {
+ wxPanel* panel = new wxPanel (parent);
+
+ wxBoxSizer* s = new wxBoxSizer (wxVERTICAL);
+ panel->SetSizer (s);
+
+ wxFlexGridSizer* table = new wxFlexGridSizer (2, DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
+ table->AddGrowableCol (1, 1);
+ s->Add (table, 1, wxALL | wxEXPAND, _border);
+
+ add_label_to_sizer (table, panel, _("Maximum JPEG2000 bandwidth"), true);
+ _maximum_j2k_bandwidth = new wxSpinCtrl (panel);
+ table->Add (_maximum_j2k_bandwidth, 1);
+
+ _allow_any_dcp_frame_rate = new wxCheckBox (panel, wxID_ANY, _("Allow any DCP frame rate"));
+ table->Add (_allow_any_dcp_frame_rate, 1, wxEXPAND | wxALL);
+ table->AddSpacer (0);
+
+ add_label_to_sizer (table, panel, _("Log"), true);
+ _log_general = new wxCheckBox (panel, wxID_ANY, _("General"));
+ table->Add (_log_general, 1, wxEXPAND | wxALL);
+ _log_warning = new wxCheckBox (panel, wxID_ANY, _("Warnings"));
+ table->AddSpacer (0);
+ table->Add (_log_warning, 1, wxEXPAND | wxALL);
+ _log_error = new wxCheckBox (panel, wxID_ANY, _("Errors"));
+ table->AddSpacer (0);
+ table->Add (_log_error, 1, wxEXPAND | wxALL);
+ _log_timing = new wxCheckBox (panel, wxID_ANY, _("Timing"));
+ table->AddSpacer (0);
+ table->Add (_log_timing, 1, wxEXPAND | wxALL);
+
+ Config* config = Config::instance ();
+
+ _maximum_j2k_bandwidth->SetRange (1, 500);
+ _maximum_j2k_bandwidth->SetValue (config->maximum_j2k_bandwidth() / 1000000);
+ _maximum_j2k_bandwidth->Bind (wxEVT_COMMAND_SPINCTRL_UPDATED, boost::bind (&AdvancedPage::maximum_j2k_bandwidth_changed, this));
+ _allow_any_dcp_frame_rate->SetValue (config->allow_any_dcp_frame_rate ());
+ _allow_any_dcp_frame_rate->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&AdvancedPage::allow_any_dcp_frame_rate_changed, this));
+ _log_general->SetValue (config->log_types() & Log::GENERAL);
+ _log_general->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&AdvancedPage::log_changed, this));
+ _log_warning->SetValue (config->log_types() & Log::WARNING);
+ _log_warning->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&AdvancedPage::log_changed, this));
+ _log_error->SetValue (config->log_types() & Log::ERROR);
+ _log_error->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&AdvancedPage::log_changed, this));
+ _log_timing->SetValue (config->log_types() & Log::TIMING);
+ _log_timing->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&AdvancedPage::log_changed, this));
+
+ return panel;
+ }
+
+private:
+
+ void maximum_j2k_bandwidth_changed ()
+ {
+ Config::instance()->set_maximum_j2k_bandwidth (_maximum_j2k_bandwidth->GetValue() * 1000000);
+ }
+
+ void allow_any_dcp_frame_rate_changed ()
+ {
+ Config::instance()->set_allow_any_dcp_frame_rate (_allow_any_dcp_frame_rate->GetValue ());
+ }
+
+ void log_changed ()
+ {
+ int types = 0;
+ if (_log_general->GetValue ()) {
+ types |= Log::GENERAL;
+ }
+ if (_log_warning->GetValue ()) {
+ types |= Log::WARNING;
+ }
+ if (_log_error->GetValue ()) {
+ types |= Log::ERROR;
+ }
+ if (_log_timing->GetValue ()) {
+ types |= Log::TIMING;
+ }
+ Config::instance()->set_log_types (types);
+ }
+
+ wxSpinCtrl* _maximum_j2k_bandwidth;
+ wxCheckBox* _allow_any_dcp_frame_rate;
+ wxCheckBox* _log_general;
+ wxCheckBox* _log_warning;
+ wxCheckBox* _log_error;
+ wxCheckBox* _log_timing;
+};
+
wxPreferencesEditor*
create_config_dialog ()
{
e->AddPage (new ColourConversionsPage (ps, border));
e->AddPage (new TMSPage (ps, border));
e->AddPage (new KDMEmailPage (ps, border));
+ e->AddPage (new AdvancedPage (ps, border));
return e;
}
p += sub_image->stride()[0];
}
+ shared_ptr<FileLog> log (new FileLog ("build/test/client_server_test.log"));
+
shared_ptr<PlayerVideoFrame> pvf (
new PlayerVideoFrame (
- shared_ptr<ImageProxy> (new RawImageProxy (image)),
+ shared_ptr<ImageProxy> (new RawImageProxy (image, log)),
Crop (),
libdcp::Size (1998, 1080),
libdcp::Size (1998, 1080),
pvf->set_subtitle (sub_image, Position<int> (50, 60));
- shared_ptr<FileLog> log (new FileLog ("build/test/client_server_test.log"));
-
shared_ptr<DCPVideoFrame> frame (
new DCPVideoFrame (
pvf,