* Add subtitle view.
+2014-05-16 Carl Hetherington <cth@carlh.net>
+
+ * Version 1.69.8 released.
+
+2014-05-16 Carl Hetherington <cth@carlh.net>
+
+ * Fix various confusions in translations of abbreviated
+ channel names (Lc, Rc etc.)
+
+2014-05-14 Carl Hetherington <cth@carlh.net>
+
+ * Version 1.69.7 released.
+
+2014-05-14 Carl Hetherington <cth@carlh.net>
+
+ * Bump libdcp to remove checks on PCM MXF edit rates,
+ so we can generate strange ones in DCP-o-matic.
+
+2014-05-13 Carl Hetherington <cth@carlh.net>
+
+ * Version 1.69.6 released.
+
+2014-05-13 Carl Hetherington <cth@carlh.net>
+
+ * Remove artificial 100fps limit when using
+ "any" DCP frame rate.
+
+2014-05-12 Carl Hetherington <cth@carlh.net>
+
+ * Version 1.69.5 released.
+
+2014-05-12 Carl Hetherington <cth@carlh.net>
+
+ * Add option to use any DCP frame rate, rather than just
+ the "allowed" set.
+
+ * Version 1.69.4 released.
+
+2014-05-12 Carl Hetherington <cth@carlh.net>
+
+ * Version 1.69.3 released.
+
+2014-05-12 Carl Hetherington <cth@carlh.net>
+
+ * Use libdcp::raw_convert instead of boost::lexical_cast and
+ LocaleGuard, hopefully to fix large numbers being written with
+ thousands separators on some locales.
+
2014-05-10 Carl Hetherington <cth@carlh.net>
* Version 1.69.2 released.
-dcpomatic (1.69.2-1) UNRELEASED; urgency=low
+dcpomatic (1.69.8-1) UNRELEASED; urgency=low
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
+ * New upstream release.
+ * New upstream release.
+ * New upstream release.
+ * New upstream release.
+ * New upstream release.
+ * New upstream release.
- -- Carl Hetherington <carl@d1stkfactory> Sat, 10 May 2014 13:40:32 +0100
+ -- Carl Hetherington <carl@d1stkfactory> Fri, 16 May 2014 11:45:03 +0100
dcpomatic (0.87-1) UNRELEASED; urgency=low
*/
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "audio_content.h"
#include "analyse_audio_job.h"
#include "job_manager.h"
using std::string;
using std::vector;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::dynamic_pointer_cast;
+using dcp::raw_convert;
int const AudioContentProperty::AUDIO_CHANNELS = 200;
int const AudioContentProperty::AUDIO_LENGTH = 201;
AudioContent::AudioContent (shared_ptr<const Film> f, shared_ptr<const cxml::Node> node)
: Content (f, node)
{
- LocaleGuard lg;
-
_audio_gain = node->number_child<float> ("AudioGain");
_audio_delay = node->number_child<int> ("AudioDelay");
}
void
AudioContent::as_xml (xmlpp::Node* node) const
{
- LocaleGuard lg;
-
boost::mutex::scoped_lock lm (_mutex);
- node->add_child("AudioGain")->add_child_text (lexical_cast<string> (_audio_gain));
- node->add_child("AudioDelay")->add_child_text (lexical_cast<string> (_audio_delay));
+ node->add_child("AudioGain")->add_child_text (raw_convert<string> (_audio_gain));
+ node->add_child("AudioDelay")->add_child_text (raw_convert<string> (_audio_delay));
}
*/
-#include <boost/lexical_cast.hpp>
#include <libxml++/libxml++.h>
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "audio_mapping.h"
#include "util.h"
using std::string;
using std::min;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::dynamic_pointer_cast;
+using dcp::raw_convert;
AudioMapping::AudioMapping ()
: _content_channels (0)
set (
(*i)->number_attribute<int> ("Content"),
static_cast<dcp::Channel> ((*i)->number_attribute<int> ("DCP")),
- lexical_cast<float> ((*i)->content ())
+ raw_convert<float> ((*i)->content ())
);
}
}
void
AudioMapping::as_xml (xmlpp::Node* node) const
{
- node->add_child ("ContentChannels")->add_child_text (lexical_cast<string> (_content_channels));
+ node->add_child ("ContentChannels")->add_child_text (raw_convert<string> (_content_channels));
for (int c = 0; c < _content_channels; ++c) {
for (int d = 0; d < MAX_DCP_AUDIO_CHANNELS; ++d) {
xmlpp::Element* t = node->add_child ("Gain");
- t->set_attribute ("Content", lexical_cast<string> (c));
- t->set_attribute ("DCP", lexical_cast<string> (d));
- t->add_child_text (lexical_cast<string> (get (c, static_cast<dcp::Channel> (d))));
+ t->set_attribute ("Content", raw_convert<string> (c));
+ t->set_attribute ("DCP", raw_convert<string> (d));
+ t->add_child_text (raw_convert<string> (get (c, static_cast<dcp::Channel> (d))));
}
}
}
*/
-#include <boost/lexical_cast.hpp>
#include <libxml++/libxml++.h>
#include <dcp/colour_matrix.h>
+#include <dcp/raw_convert.h>
#include <libcxml/cxml.h>
#include "config.h"
#include "colour_conversion.h"
using std::cout;
using std::vector;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::optional;
+using dcp::raw_convert;
ColourConversion::ColourConversion ()
: input_gamma (2.4)
ColourConversion::ColourConversion (cxml::NodePtr node)
: matrix (3, 3)
{
- LocaleGuard lg;
-
input_gamma = node->number_child<double> ("InputGamma");
input_gamma_linearised = node->bool_child ("InputGammaLinearised");
for (list<cxml::NodePtr>::iterator i = m.begin(); i != m.end(); ++i) {
int const ti = (*i)->number_attribute<int> ("i");
int const tj = (*i)->number_attribute<int> ("j");
- matrix(ti, tj) = lexical_cast<double> ((*i)->content ());
+ matrix(ti, tj) = raw_convert<double> ((*i)->content ());
}
output_gamma = node->number_child<double> ("OutputGamma");
void
ColourConversion::as_xml (xmlpp::Node* node) const
{
- LocaleGuard lg;
-
- node->add_child("InputGamma")->add_child_text (lexical_cast<string> (input_gamma));
+ node->add_child("InputGamma")->add_child_text (raw_convert<string> (input_gamma));
node->add_child("InputGammaLinearised")->add_child_text (input_gamma_linearised ? "1" : "0");
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
xmlpp::Element* m = node->add_child("Matrix");
- m->set_attribute ("i", lexical_cast<string> (i));
- m->set_attribute ("j", lexical_cast<string> (j));
- m->add_child_text (lexical_cast<string> (matrix (i, j)));
+ m->set_attribute ("i", raw_convert<string> (i));
+ m->set_attribute ("j", raw_convert<string> (j));
+ m->add_child_text (raw_convert<string> (matrix (i, j)));
}
}
- node->add_child("OutputGamma")->add_child_text (lexical_cast<string> (output_gamma));
+ node->add_child("OutputGamma")->add_child_text (raw_convert<string> (output_gamma));
}
optional<size_t>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <dcp/colour_matrix.h>
+#include <dcp/raw_convert.h>
#include <libcxml/cxml.h>
#include "config.h"
#include "server.h"
using std::exception;
using std::cerr;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::optional;
using boost::algorithm::is_any_of;
using boost::algorithm::split;
+using dcp::raw_convert;
Config* Config::_instance = 0;
, _use_any_servers (true)
, _tms_path (".")
, _sound_processor (SoundProcessor::from_id (N_("dolby_cp750")))
+ , _allow_any_dcp_frame_rate (false)
, _default_still_length (10)
, _default_container (Ratio::from_id ("185"))
, _default_dcp_content_type (DCPContentType::from_dci_name ("TST"))
void
Config::read ()
{
- LocaleGuard lg;
-
if (!boost::filesystem::exists (file (false))) {
read_old_metadata ();
return;
_check_for_test_updates = f.optional_bool_child("CheckForTestUpdates").get_value_or (false);
_maximum_j2k_bandwidth = f.optional_number_child<int> ("MaximumJ2KBandwidth").get_value_or (250000000);
+ _allow_any_dcp_frame_rate = f.optional_bool_child ("AllowAnyDCPFrameRate");
}
void
void
Config::write () const
{
- LocaleGuard lg;
-
xmlpp::Document doc;
xmlpp::Element* root = doc.create_root_node ("Config");
root->add_child("Version")->add_child_text ("1");
- root->add_child("NumLocalEncodingThreads")->add_child_text (lexical_cast<string> (_num_local_encoding_threads));
+ root->add_child("NumLocalEncodingThreads")->add_child_text (raw_convert<string> (_num_local_encoding_threads));
root->add_child("DefaultDirectory")->add_child_text (_default_directory.string ());
- root->add_child("ServerPortBase")->add_child_text (lexical_cast<string> (_server_port_base));
+ root->add_child("ServerPortBase")->add_child_text (raw_convert<string> (_server_port_base));
root->add_child("UseAnyServers")->add_child_text (_use_any_servers ? "1" : "0");
for (vector<string>::const_iterator i = _servers.begin(); i != _servers.end(); ++i) {
_default_dci_metadata.as_xml (root->add_child ("DCIMetadata"));
- root->add_child("DefaultStillLength")->add_child_text (lexical_cast<string> (_default_still_length));
- root->add_child("DefaultJ2KBandwidth")->add_child_text (lexical_cast<string> (_default_j2k_bandwidth));
- root->add_child("DefaultAudioDelay")->add_child_text (lexical_cast<string> (_default_audio_delay));
+ root->add_child("DefaultStillLength")->add_child_text (raw_convert<string> (_default_still_length));
+ root->add_child("DefaultJ2KBandwidth")->add_child_text (raw_convert<string> (_default_j2k_bandwidth));
+ root->add_child("DefaultAudioDelay")->add_child_text (raw_convert<string> (_default_audio_delay));
for (vector<PresetColourConversion>::const_iterator i = _colour_conversions.begin(); i != _colour_conversions.end(); ++i) {
i->as_xml (root->add_child ("ColourConversion"));
root->add_child("CheckForUpdates")->add_child_text (_check_for_updates ? "1" : "0");
root->add_child("CheckForTestUpdates")->add_child_text (_check_for_test_updates ? "1" : "0");
- root->add_child("MaximumJ2KBandwidth")->add_child_text (lexical_cast<string> (_maximum_j2k_bandwidth));
-
+ 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");
+
doc.write_to_file_formatted (file(false).string ());
}
std::list<int> allowed_dcp_frame_rates () const {
return _allowed_dcp_frame_rates;
}
+
+ bool allow_any_dcp_frame_rate () const {
+ return _allow_any_dcp_frame_rate;
+ }
DCIMetadata default_dci_metadata () const {
return _default_dci_metadata;
changed ();
}
+ void set_allow_any_dcp_frame_rate (bool a) {
+ _allow_any_dcp_frame_rate = a;
+ changed ();
+ }
+
void set_default_dci_metadata (DCIMetadata d) {
_default_dci_metadata = d;
changed ();
/** Our sound processor */
SoundProcessor const * _sound_processor;
std::list<int> _allowed_dcp_frame_rates;
+ /** Allow any video frame rate for the DCP; if true, overrides _allowed_dcp_frame_rates */
+ bool _allow_any_dcp_frame_rate;
/** Default DCI metadata for newly-created Films */
DCIMetadata _default_dci_metadata;
boost::optional<std::string> _language;
#include <boost/thread/mutex.hpp>
#include <libxml++/libxml++.h>
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "content.h"
#include "util.h"
#include "content_factory.h"
using std::cout;
using std::vector;
using boost::shared_ptr;
-using boost::lexical_cast;
+using dcp::raw_convert;
int const ContentProperty::PATH = 400;
int const ContentProperty::POSITION = 401;
node->add_child("Path")->add_child_text (i->string ());
}
node->add_child("Digest")->add_child_text (_digest);
- node->add_child("Position")->add_child_text (lexical_cast<string> (_position.get ()));
- node->add_child("TrimStart")->add_child_text (lexical_cast<string> (_trim_start.get ()));
- node->add_child("TrimEnd")->add_child_text (lexical_cast<string> (_trim_end.get ()));
+ node->add_child("Position")->add_child_text (raw_convert<string> (_position.get ()));
+ node->add_child("TrimStart")->add_child_text (raw_convert<string> (_trim_start.get ()));
+ node->add_child("TrimEnd")->add_child_text (raw_convert<string> (_trim_end.get ()));
}
void
/*
- 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 <iostream>
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "dci_metadata.h"
#include "i18n.h"
using std::string;
-using boost::lexical_cast;
using boost::shared_ptr;
+using dcp::raw_convert;
DCIMetadata::DCIMetadata (shared_ptr<const cxml::Node> node)
{
void
DCIMetadata::as_xml (xmlpp::Node* root) const
{
- root->add_child("ContentVersion")->add_child_text (lexical_cast<string> (content_version));
+ root->add_child("ContentVersion")->add_child_text (raw_convert<string> (content_version));
root->add_child("AudioLanguage")->add_child_text (audio_language);
root->add_child("SubtitleLanguage")->add_child_text (subtitle_language);
root->add_child("Territory")->add_child_text (territory);
#include <dcp/xyz_frame.h>
#include <dcp/rgb_xyz.h>
#include <dcp/colour_matrix.h>
+#include <dcp/raw_convert.h>
#include <libcxml/cxml.h>
#include "film.h"
#include "dcp_video_frame.h"
using boost::shared_ptr;
using boost::lexical_cast;
using dcp::Size;
+using dcp::raw_convert;
#define DCI_COEFFICENT (48.0 / 52.37)
{
boost::asio::io_service io_service;
boost::asio::ip::tcp::resolver resolver (io_service);
- boost::asio::ip::tcp::resolver::query query (serv.host_name(), boost::lexical_cast<string> (Config::instance()->server_port_base ()));
+ boost::asio::ip::tcp::resolver::query query (serv.host_name(), raw_convert<string> (Config::instance()->server_port_base ()));
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query);
shared_ptr<Socket> socket (new Socket);
xmlpp::Document doc;
xmlpp::Element* root = doc.create_root_node ("EncodingRequest");
- root->add_child("Version")->add_child_text (lexical_cast<string> (SERVER_LINK_VERSION));
- root->add_child("Width")->add_child_text (lexical_cast<string> (_image->size().width));
- root->add_child("Height")->add_child_text (lexical_cast<string> (_image->size().height));
+ root->add_child("Version")->add_child_text (raw_convert<string> (SERVER_LINK_VERSION));
+ root->add_child("Width")->add_child_text (raw_convert<string> (_image->size().width));
+ root->add_child("Height")->add_child_text (raw_convert<string> (_image->size().height));
add_metadata (root);
stringstream xml;
void
DCPVideoFrame::add_metadata (xmlpp::Element* el) const
{
- el->add_child("Frame")->add_child_text (lexical_cast<string> (_frame));
+ el->add_child("Frame")->add_child_text (raw_convert<string> (_frame));
switch (_eyes) {
case EYES_BOTH:
_conversion.as_xml (el->add_child("ColourConversion"));
- el->add_child("FramesPerSecond")->add_child_text (lexical_cast<string> (_frames_per_second));
- el->add_child("J2KBandwidth")->add_child_text (lexical_cast<string> (_j2k_bandwidth));
- el->add_child("Resolution")->add_child_text (lexical_cast<string> (int (_resolution)));
+ el->add_child("FramesPerSecond")->add_child_text (raw_convert<string> (_frames_per_second));
+ el->add_child("J2KBandwidth")->add_child_text (raw_convert<string> (_j2k_bandwidth));
+ el->add_child("Resolution")->add_child_text (raw_convert<string> (int (_resolution)));
}
EncodedData::EncodedData (int s)
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
+#include <dcp/raw_convert.h>
#include "ffmpeg.h"
#include "ffmpeg_content.h"
#include "exceptions.h"
using std::cout;
using std::stringstream;
using boost::shared_ptr;
-using boost::lexical_cast;
+using dcp::raw_convert;
boost::mutex FFmpeg::_mutex;
/* These durations are in microseconds, and represent how far into the content file
we will look for streams.
*/
- av_dict_set (&options, "analyzeduration", lexical_cast<string> (5 * 60 * 1e6).c_str(), 0);
- av_dict_set (&options, "probesize", lexical_cast<string> (5 * 60 * 1e6).c_str(), 0);
+ av_dict_set (&options, "analyzeduration", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
+ av_dict_set (&options, "probesize", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
if (avformat_open_input (&_format_context, 0, 0, &options) < 0) {
throw OpenFileError (_ffmpeg_content->path(0).string ());
#include <libavformat/avformat.h>
}
#include <libcxml/cxml.h>
+#include <libdcp/raw_convert.h>
#include "ffmpeg_content.h"
#include "ffmpeg_examiner.h"
#include "compose.hpp"
using std::cout;
using std::pair;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::dynamic_pointer_cast;
+using libdcp::raw_convert;
int const FFmpegContentProperty::SUBTITLE_STREAMS = 100;
int const FFmpegContentProperty::SUBTITLE_STREAM = 101;
}
if (_first_video) {
- node->add_child("FirstVideo")->add_child_text (lexical_cast<string> (_first_video.get().get()));
+ node->add_child("FirstVideo")->add_child_text (raw_convert<string> (_first_video.get().get()));
}
}
FFmpegStream::as_xml (xmlpp::Node* root) const
{
root->add_child("Name")->add_child_text (name);
- root->add_child("Id")->add_child_text (lexical_cast<string> (_id));
+ root->add_child("Id")->add_child_text (raw_convert<string> (_id));
}
FFmpegAudioStream::FFmpegAudioStream (shared_ptr<const cxml::Node> node, int version)
FFmpegAudioStream::as_xml (xmlpp::Node* root) const
{
FFmpegStream::as_xml (root);
- root->add_child("FrameRate")->add_child_text (lexical_cast<string> (frame_rate));
- root->add_child("Channels")->add_child_text (lexical_cast<string> (channels));
+ root->add_child("FrameRate")->add_child_text (raw_convert<string> (frame_rate));
+ root->add_child("Channels")->add_child_text (raw_convert<string> (channels));
if (first_audio) {
- root->add_child("FirstAudio")->add_child_text (lexical_cast<string> (first_audio.get().get()));
+ root->add_child("FirstAudio")->add_child_text (raw_convert<string> (first_audio.get().get()));
}
mapping.as_xml (root->add_child("Mapping"));
}
#define DCPOMATIC_FFMPEG_CONTENT_H
#include <boost/enable_shared_from_this.hpp>
+#include <boost/lexical_cast.hpp>
#include "video_content.h"
#include "audio_content.h"
#include "subtitle_content.h"
#include <iomanip>
#include <iostream>
#include <stdint.h>
-#include <boost/lexical_cast.hpp>
#include <sndfile.h>
extern "C" {
#include <libavcodec/avcodec.h>
#include <dcp/signer.h>
#include <dcp/util.h>
#include <dcp/local_time.h>
+#include <dcp/raw_convert.h>
#include "film.h"
#include "job.h"
#include "util.h"
using std::list;
using boost::shared_ptr;
using boost::weak_ptr;
-using boost::lexical_cast;
using boost::dynamic_pointer_cast;
using boost::to_upper_copy;
using boost::ends_with;
using boost::optional;
using dcp::Size;
using dcp::Signer;
+using dcp::raw_convert;
/* 5 -> 6
* AudioMapping XML changed.
Film::video_identifier () const
{
assert (container ());
- LocaleGuard lg;
stringstream s;
+ s.imbue (std::locale::classic ());
+
s << container()->id()
<< "_" << resolution_to_string (_resolution)
<< "_" << _playlist->video_identifier()
shared_ptr<xmlpp::Document>
Film::metadata () const
{
- LocaleGuard lg;
-
shared_ptr<xmlpp::Document> doc (new xmlpp::Document);
xmlpp::Element* root = doc->create_root_node ("Metadata");
- root->add_child("Version")->add_child_text (lexical_cast<string> (current_state_version));
+ root->add_child("Version")->add_child_text (raw_convert<string> (current_state_version));
root->add_child("Name")->add_child_text (_name);
root->add_child("UseDCIName")->add_child_text (_use_dci_name ? "1" : "0");
root->add_child("Resolution")->add_child_text (resolution_to_string (_resolution));
root->add_child("Scaler")->add_child_text (_scaler->id ());
root->add_child("WithSubtitles")->add_child_text (_with_subtitles ? "1" : "0");
- root->add_child("J2KBandwidth")->add_child_text (lexical_cast<string> (_j2k_bandwidth));
+ root->add_child("J2KBandwidth")->add_child_text (raw_convert<string> (_j2k_bandwidth));
_dci_metadata.as_xml (root->add_child ("DCIMetadata"));
- root->add_child("VideoFrameRate")->add_child_text (lexical_cast<string> (_video_frame_rate));
+ root->add_child("VideoFrameRate")->add_child_text (raw_convert<string> (_video_frame_rate));
root->add_child("DCIDate")->add_child_text (boost::gregorian::to_iso_string (_dci_date));
- root->add_child("AudioChannels")->add_child_text (lexical_cast<string> (_audio_channels));
+ root->add_child("AudioChannels")->add_child_text (raw_convert<string> (_audio_channels));
root->add_child("ThreeD")->add_child_text (_three_d ? "1" : "0");
root->add_child("SequenceVideo")->add_child_text (_sequence_video ? "1" : "0");
root->add_child("Interop")->add_child_text (_interop ? "1" : "0");
list<string>
Film::read_metadata ()
{
- LocaleGuard lg;
-
if (boost::filesystem::exists (file ("metadata")) && !boost::filesystem::exists (file ("metadata.xml"))) {
throw StringError (_("This film was created with an older version of DCP-o-matic, and unfortunately it cannot be loaded into this version. You will need to create a new Film, re-add your content and set it up again. Sorry!"));
}
*/
#include <iostream>
-#include <boost/lexical_cast.hpp>
#include <Magick++.h>
#include "image_content.h"
#include "image_examiner.h"
using std::list;
using std::sort;
using boost::shared_ptr;
-using boost::lexical_cast;
-using boost::bad_lexical_cast;
ImageExaminer::ImageExaminer (shared_ptr<const Film> film, shared_ptr<const ImageContent> content, shared_ptr<Job>)
: _film (film)
return cinema_kdms;
}
+/** @param from KDM from time in local time.
+ * @param to KDM to time in local time.
+ */
void
write_kdm_files (
shared_ptr<const Film> film,
#include <libcxml/cxml.h>
#include <boost/shared_ptr.hpp>
-#include <boost/lexical_cast.hpp>
#include "playlist.h"
#include "sndfile_content.h"
#include "sndfile_decoder.h"
using boost::shared_ptr;
using boost::weak_ptr;
using boost::dynamic_pointer_cast;
-using boost::lexical_cast;
Playlist::Playlist ()
: _sequence_video (true)
#include <sstream>
#include <iostream>
#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
#include <boost/scoped_array.hpp>
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "server.h"
#include "util.h"
#include "scaler.h"
using boost::bind;
using boost::scoped_array;
using boost::optional;
-using boost::lexical_cast;
using dcp::Size;
+using dcp::raw_convert;
Server::Server (shared_ptr<Log> log, bool verbose)
: _log (log)
/* Reply to the client saying what we can do */
xmlpp::Document doc;
xmlpp::Element* root = doc.create_root_node ("ServerAvailable");
- root->add_child("Threads")->add_child_text (lexical_cast<string> (_worker_threads.size ()));
+ root->add_child("Threads")->add_child_text (raw_convert<string> (_worker_threads.size ()));
stringstream xml;
doc.write_to_stream (xml, "UTF-8");
*/
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "server_finder.h"
#include "exceptions.h"
#include "util.h"
using std::cout;
using boost::shared_ptr;
using boost::scoped_array;
-using boost::lexical_cast;
+using dcp::raw_convert;
ServerFinder* ServerFinder::_instance = 0;
}
try {
boost::asio::ip::udp::resolver resolver (io_service);
- boost::asio::ip::udp::resolver::query query (*i, lexical_cast<string> (Config::instance()->server_port_base() + 1));
+ boost::asio::ip::udp::resolver::query query (*i, raw_convert<string> (Config::instance()->server_port_base() + 1));
boost::asio::ip::udp::endpoint end_point (*resolver.resolve (query));
socket.send_to (boost::asio::buffer (data.c_str(), data.size() + 1), end_point);
} catch (...) {
*/
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "sndfile_content.h"
#include "sndfile_decoder.h"
#include "film.h"
using std::stringstream;
using std::cout;
using boost::shared_ptr;
-using boost::lexical_cast;
+using dcp::raw_convert;
SndfileContent::SndfileContent (shared_ptr<const Film> f, boost::filesystem::path p)
: Content (f, p)
Content::as_xml (node);
AudioContent::as_xml (node);
- node->add_child("AudioChannels")->add_child_text (lexical_cast<string> (audio_channels ()));
- node->add_child("AudioLength")->add_child_text (lexical_cast<string> (audio_length().get ()));
- node->add_child("AudioFrameRate")->add_child_text (lexical_cast<string> (audio_frame_rate ()));
+ node->add_child("AudioChannels")->add_child_text (raw_convert<string> (audio_channels ()));
+ node->add_child("AudioLength")->add_child_text (raw_convert<string> (audio_length().get ()));
+ node->add_child("AudioFrameRate")->add_child_text (raw_convert<string> (audio_frame_rate ()));
_audio_mapping.as_xml (node->add_child("AudioMapping"));
}
#include "util.h"
#include "subrip.h"
#include "film.h"
+#include <dcp/raw_convert.h>
#include "i18n.h"
using std::stringstream;
using std::string;
using std::cout;
+using dcp::raw_convert;
using boost::shared_ptr;
using boost::lexical_cast;
void
SubRipContent::as_xml (xmlpp::Node* node) const
{
- LocaleGuard lg;
-
node->add_child("Type")->add_child_text ("SubRip");
Content::as_xml (node);
SubtitleContent::as_xml (node);
- node->add_child("Length")->add_child_text (lexical_cast<string> (_length.get ()));
+ node->add_child("Length")->add_child_text (raw_convert<string> (_length.get ()));
}
DCPTime
string
SubRipContent::identifier () const
{
- LocaleGuard lg;
-
stringstream s;
s << Content::identifier()
- << "_" << subtitle_scale()
- << "_" << subtitle_x_offset()
- << "_" << subtitle_y_offset();
+ << "_" << raw_convert<string> (subtitle_scale())
+ << "_" << raw_convert<string> (subtitle_x_offset())
+ << "_" << raw_convert<string> (subtitle_y_offset());
return s.str ();
}
/*
- Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2013-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 <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "subtitle_content.h"
#include "util.h"
#include "exceptions.h"
using std::vector;
using std::cout;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::dynamic_pointer_cast;
+using dcp::raw_convert;
int const SubtitleContentProperty::SUBTITLE_X_OFFSET = 500;
int const SubtitleContentProperty::SUBTITLE_Y_OFFSET = 501;
, _subtitle_y_offset (0)
, _subtitle_scale (1)
{
- LocaleGuard lg;
-
if (version >= 7) {
_subtitle_x_offset = node->number_child<float> ("SubtitleXOffset");
_subtitle_y_offset = node->number_child<float> ("SubtitleYOffset");
void
SubtitleContent::as_xml (xmlpp::Node* root) const
{
- LocaleGuard lg;
-
- root->add_child("SubtitleXOffset")->add_child_text (lexical_cast<string> (_subtitle_x_offset));
- root->add_child("SubtitleYOffset")->add_child_text (lexical_cast<string> (_subtitle_y_offset));
- root->add_child("SubtitleScale")->add_child_text (lexical_cast<string> (_subtitle_scale));
+ root->add_child("SubtitleXOffset")->add_child_text (raw_convert<string> (_subtitle_x_offset));
+ root->add_child("SubtitleYOffset")->add_child_text (raw_convert<string> (_subtitle_y_offset));
+ root->add_child("SubtitleScale")->add_child_text (raw_convert<string> (_subtitle_scale));
}
void
#include <boost/algorithm/string.hpp>
#include <curl/curl.h>
#include <libcxml/cxml.h>
+#include <dcp/raw_convert.h>
#include "update.h"
#include "version.h"
#include "ui_signaller.h"
using std::min;
using std::string;
using std::stringstream;
-using boost::lexical_cast;
+using dcp::raw_convert;
/** Singleton instance */
UpdateChecker* UpdateChecker::_instance = 0;
current_pre = true;
}
- float current_float = lexical_cast<float> (current);
+ float current_float = raw_convert<float> (current);
if (current_pre) {
current_float -= 0.005;
}
- if (current_float < lexical_cast<float> (_stable)) {
+ if (current_float < raw_convert<float> (_stable)) {
set_state (YES);
} else {
set_state (NO);
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>
-#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>
#include <boost/filesystem.hpp>
#ifdef DCPOMATIC_WINDOWS
#include <dcp/util.h>
#include <dcp/signer_chain.h>
#include <dcp/signer.h>
+#include <dcp/raw_convert.h>
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
using std::set_terminate;
using boost::shared_ptr;
using boost::thread;
-using boost::lexical_cast;
using boost::optional;
using dcp::Size;
+using dcp::raw_convert;
static boost::thread::id ui_thread;
static boost::filesystem::path backtrace_file;
get_required_int (multimap<string, string> const & kv, string k)
{
string const v = get_required_string (kv, k);
- return lexical_cast<int> (v);
+ return raw_convert<int> (v);
}
float
get_required_float (multimap<string, string> const & kv, string k)
{
string const v = get_required_string (kv, k);
- return lexical_cast<float> (v);
+ return raw_convert<float> (v);
}
string
return 0;
}
- return lexical_cast<int> (i->second);
+ return raw_convert<int> (i->second);
}
/** Trip an assert if the caller is not in the UI thread */
return channels[c];
}
-LocaleGuard::LocaleGuard ()
- : _old (0)
-{
- char const * old = setlocale (LC_NUMERIC, 0);
-
- if (old) {
- _old = strdup (old);
- if (strcmp (_old, "C")) {
- setlocale (LC_NUMERIC, "C");
- }
- }
-}
-
-LocaleGuard::~LocaleGuard ()
-{
- setlocale (LC_NUMERIC, _old);
- free (_old);
-}
-
bool
valid_image_file (boost::filesystem::path f)
{
int _timeout;
};
-class LocaleGuard
-{
-public:
- LocaleGuard ();
- ~LocaleGuard ();
-
-private:
- char* _old;
-};
+extern int64_t video_frames_to_audio_frames (VideoContent::Frame v, float audio_sample_rate, float frames_per_second);
/** @class ScopedTemporary
* @brief A temporary file which is deleted when the ScopedTemporary object goes out of scope.
#include <iomanip>
#include <libcxml/cxml.h>
#include <dcp/colour_matrix.h>
+#include <dcp/raw_convert.h>
#include "video_content.h"
#include "video_examiner.h"
#include "compose.hpp"
using std::cout;
using std::vector;
using boost::shared_ptr;
-using boost::lexical_cast;
using boost::optional;
using boost::dynamic_pointer_cast;
+using dcp::raw_convert;
vector<VideoContentScale> VideoContentScale::_scales;
VideoContent::as_xml (xmlpp::Node* node) const
{
boost::mutex::scoped_lock lm (_mutex);
- node->add_child("VideoLength")->add_child_text (lexical_cast<string> (_video_length.get ()));
- node->add_child("VideoWidth")->add_child_text (lexical_cast<string> (_video_size.width));
- node->add_child("VideoHeight")->add_child_text (lexical_cast<string> (_video_size.height));
- node->add_child("VideoFrameRate")->add_child_text (lexical_cast<string> (_video_frame_rate));
- node->add_child("VideoFrameType")->add_child_text (lexical_cast<string> (static_cast<int> (_video_frame_type)));
- node->add_child("LeftCrop")->add_child_text (boost::lexical_cast<string> (_crop.left));
- node->add_child("RightCrop")->add_child_text (boost::lexical_cast<string> (_crop.right));
- node->add_child("TopCrop")->add_child_text (boost::lexical_cast<string> (_crop.top));
- node->add_child("BottomCrop")->add_child_text (boost::lexical_cast<string> (_crop.bottom));
+ node->add_child("VideoLength")->add_child_text (raw_convert<string> (_video_length.get ()));
+ node->add_child("VideoWidth")->add_child_text (raw_convert<string> (_video_size.width));
+ node->add_child("VideoHeight")->add_child_text (raw_convert<string> (_video_size.height));
+ node->add_child("VideoFrameRate")->add_child_text (raw_convert<string> (_video_frame_rate));
+ node->add_child("VideoFrameType")->add_child_text (raw_convert<string> (static_cast<int> (_video_frame_type)));
+ node->add_child("LeftCrop")->add_child_text (raw_convert<string> (_crop.left));
+ node->add_child("RightCrop")->add_child_text (raw_convert<string> (_crop.right));
+ node->add_child("TopCrop")->add_child_text (raw_convert<string> (_crop.top));
+ node->add_child("BottomCrop")->add_child_text (raw_convert<string> (_crop.bottom));
_scale.as_xml (node->add_child("Scale"));
_colour_conversion.as_xml (node->add_child("ColourConversion"));
}
void file_exit ()
{
- Close (true);
+ /* false here allows the close handler to veto the close request */
+ Close (false);
}
void edit_preferences ()
#include "audio_mapping_view.h"
#include "wx_util.h"
#include "audio_gain_dialog.h"
+#include <boost/lexical_cast.hpp>
using std::cout;
using std::list;
void Draw (wxGrid& grid, wxGridCellAttr &, wxDC& dc, const wxRect& rect, int row, int col, bool)
{
- LocaleGuard lg;
-
dc.SetPen (*wxThePenList->FindOrCreatePen (wxColour (255, 255, 255), 1, wxPENSTYLE_SOLID));
dc.SetBrush (*wxTheBrushList->FindOrCreateBrush (wxColour (255, 255, 255), wxBRUSHSTYLE_SOLID));
dc.DrawRectangle (rect);
void
AudioMappingView::update_cells ()
{
- LocaleGuard lg;
-
if (_grid->GetNumberRows ()) {
_grid->DeleteRows (0, _grid->GetNumberRows ());
}
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);
_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_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;
{
add_label_to_grid_bag_sizer (grid, _dcp_panel, _("Frame Rate"), true, wxGBPosition (r, 0));
- wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
- _frame_rate = new wxChoice (_dcp_panel, wxID_ANY);
- s->Add (_frame_rate, 1, wxALIGN_CENTER_VERTICAL);
+ _frame_rate_sizer = new wxBoxSizer (wxHORIZONTAL);
+ _frame_rate_choice = new wxChoice (_dcp_panel, wxID_ANY);
+ _frame_rate_sizer->Add (_frame_rate_choice, 1, wxALIGN_CENTER_VERTICAL);
+ _frame_rate_spin = new wxSpinCtrl (_dcp_panel, wxID_ANY);
+ _frame_rate_sizer->Add (_frame_rate_spin, 1, wxALIGN_CENTER_VERTICAL);
+ setup_frame_rate_widget ();
_best_frame_rate = new wxButton (_dcp_panel, wxID_ANY, _("Use best"));
- s->Add (_best_frame_rate, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND);
- grid->Add (s, wxGBPosition (r, 1));
+ _frame_rate_sizer->Add (_best_frame_rate, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND);
+ grid->Add (_frame_rate_sizer, wxGBPosition (r, 1));
}
++r;
list<int> const dfr = Config::instance()->allowed_dcp_frame_rates ();
for (list<int>::const_iterator i = dfr.begin(); i != dfr.end(); ++i) {
- _frame_rate->Append (std_to_wx (boost::lexical_cast<string> (*i)));
+ _frame_rate_choice->Append (std_to_wx (boost::lexical_cast<string> (*i)));
}
_audio_channels->SetRange (0, MAX_DCP_AUDIO_CHANNELS);
_j2k_bandwidth->SetRange (1, Config::instance()->maximum_j2k_bandwidth() / 1000000);
+ _frame_rate_spin->SetRange (1, 480);
_resolution->Append (_("2K"));
_resolution->Append (_("4K"));
_content_timeline->Bind (wxEVT_COMMAND_BUTTON_CLICKED, boost::bind (&FilmEditor::content_timeline_clicked, this));
_scaler->Bind (wxEVT_COMMAND_CHOICE_SELECTED, boost::bind (&FilmEditor::scaler_changed, this));
_dcp_content_type->Bind (wxEVT_COMMAND_CHOICE_SELECTED, boost::bind (&FilmEditor::dcp_content_type_changed, this));
- _frame_rate->Bind (wxEVT_COMMAND_CHOICE_SELECTED, boost::bind (&FilmEditor::frame_rate_changed, this));
+ _frame_rate_choice->Bind(wxEVT_COMMAND_CHOICE_SELECTED, boost::bind (&FilmEditor::frame_rate_choice_changed, this));
+ _frame_rate_spin->Bind (wxEVT_COMMAND_SPINCTRL_UPDATED, boost::bind (&FilmEditor::frame_rate_spin_changed, this));
_best_frame_rate->Bind (wxEVT_COMMAND_BUTTON_CLICKED, boost::bind (&FilmEditor::best_frame_rate_clicked, this));
_signed->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&FilmEditor::signed_toggled, this));
_encrypted->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&FilmEditor::encrypted_toggled, this));
_film->set_encrypted (_encrypted->GetValue ());
}
-/** Called when the name widget has been changed */
+/** Called when the frame rate choice widget has been changed */
void
-FilmEditor::frame_rate_changed ()
+FilmEditor::frame_rate_choice_changed ()
{
if (!_film) {
return;
_film->set_video_frame_rate (
boost::lexical_cast<int> (
- wx_to_std (_frame_rate->GetString (_frame_rate->GetSelection ()))
+ wx_to_std (_frame_rate_choice->GetString (_frame_rate_choice->GetSelection ()))
)
);
}
+/** Called when the frame rate spin widget has been changed */
+void
+FilmEditor::frame_rate_spin_changed ()
+{
+ if (!_film) {
+ return;
+ }
+
+ _film->set_video_frame_rate (_frame_rate_spin->GetValue ());
+}
+
void
FilmEditor::audio_channels_changed ()
{
case Film::VIDEO_FRAME_RATE:
{
bool done = false;
- for (unsigned int i = 0; i < _frame_rate->GetCount(); ++i) {
- if (wx_to_std (_frame_rate->GetString(i)) == boost::lexical_cast<string> (_film->video_frame_rate())) {
- checked_set (_frame_rate, i);
+ for (unsigned int i = 0; i < _frame_rate_choice->GetCount(); ++i) {
+ if (wx_to_std (_frame_rate_choice->GetString(i)) == boost::lexical_cast<string> (_film->video_frame_rate())) {
+ checked_set (_frame_rate_choice, i);
done = true;
break;
}
}
if (!done) {
- checked_set (_frame_rate, -1);
+ checked_set (_frame_rate_choice, -1);
}
+ _frame_rate_spin->SetValue (_film->video_frame_rate ());
+
_best_frame_rate->Enable (_film->best_video_frame_rate () != _film->video_frame_rate ());
break;
}
_signed->Enable (si);
_encrypted->Enable (s);
- _frame_rate->Enable (s);
+ _frame_rate_choice->Enable (s);
+ _frame_rate_spin->Enable (s);
_audio_channels->Enable (s);
_j2k_bandwidth->Enable (s);
_container->Enable (s);
FilmEditor::config_changed ()
{
_j2k_bandwidth->SetRange (1, Config::instance()->maximum_j2k_bandwidth() / 1000000);
+ setup_frame_rate_widget ();
+}
+
+void
+FilmEditor::setup_frame_rate_widget ()
+{
+ if (Config::instance()->allow_any_dcp_frame_rate ()) {
+ _frame_rate_choice->Hide ();
+ _frame_rate_spin->Show ();
+ } else {
+ _frame_rate_choice->Show ();
+ _frame_rate_spin->Hide ();
+ }
+
+ _frame_rate_sizer->Layout ();
}
void dcp_content_type_changed ();
void scaler_changed ();
void j2k_bandwidth_changed ();
- void frame_rate_changed ();
+ void frame_rate_choice_changed ();
+ void frame_rate_spin_changed ();
void best_frame_rate_clicked ();
void content_timeline_clicked ();
void audio_channels_changed ();
void setup_content ();
void setup_container ();
void setup_content_sensitivity ();
+ void setup_frame_rate_widget ();
void active_jobs_changed (bool);
void config_changed ();
wxChoice* _scaler;
wxSpinCtrl* _j2k_bandwidth;
wxChoice* _dcp_content_type;
- wxChoice* _frame_rate;
+ wxChoice* _frame_rate_choice;
+ wxSpinCtrl* _frame_rate_spin;
+ wxSizer* _frame_rate_sizer;
wxSpinCtrl* _audio_channels;
wxButton* _best_frame_rate;
wxCheckBox* _three_d;
KDMDialog (wxWindow *, boost::shared_ptr<const Film>);
std::list<boost::shared_ptr<Screen> > screens () const;
+
+ /** @return KDM from time in local time */
boost::posix_time::ptime from () const;
+ /** @return KDM until time in local time */
boost::posix_time::ptime until () const;
+
boost::filesystem::path dcp () const;
boost::filesystem::path directory () const;
bool write_to () const;
msgstr "L"
#: src/wx/audio_mapping_view.cc:312
-#, fuzzy
msgid "Lc"
-msgstr "L"
+msgstr "Lc"
#: src/wx/video_panel.cc:87
msgid "Left crop"
msgstr "FSK (z.B. 12)"
#: src/wx/audio_mapping_view.cc:316
-#, fuzzy
msgid "Rc"
-msgstr "R"
+msgstr "Rc"
#: src/wx/content_menu.cc:54 src/wx/film_editor.cc:284
#: src/wx/editable_list.h:66
#: src/wx/audio_mapping_view.cc:320
msgid "BsL"
-msgstr ""
+msgstr "BsL"
#: src/wx/audio_mapping_view.cc:324
msgid "BsR"
-msgstr ""
+msgstr "BsR"
#: src/wx/gain_calculator_dialog.cc:32
msgid "But I have to use fader"
#: src/wx/audio_mapping_view.cc:288
msgid "C"
-msgstr ""
+msgstr "C"
#: src/wx/audio_panel.cc:63
msgid "Calculate..."
#: src/wx/audio_mapping_view.cc:304
msgid "HI"
-msgstr ""
+msgstr "HI"
#: src/wx/hints_dialog.cc:26
msgid "Hints"
#: src/wx/audio_mapping_view.cc:280
msgid "L"
-msgstr ""
+msgstr "L"
#: src/wx/audio_mapping_view.cc:312
msgid "Lc"
-msgstr ""
+msgstr "Lc"
#: src/wx/video_panel.cc:87
msgid "Left crop"
#: src/wx/audio_mapping_view.cc:292
msgid "Lfe"
-msgstr ""
+msgstr "Lfe"
#: src/wx/colour_conversion_editor.cc:49
msgid "Linearise input gamma curve for low values"
msgstr ""
#: src/wx/audio_mapping_view.cc:296
-#, fuzzy
msgid "Ls"
-msgstr "s"
+msgstr "Ls"
#: src/wx/film_editor.cc:749
msgid "MISSING: "
#: src/wx/audio_mapping_view.cc:284
msgid "R"
-msgstr ""
+msgstr "R"
#: src/wx/audio_dialog.cc:61
msgid "RMS"
#: src/wx/audio_mapping_view.cc:316
msgid "Rc"
-msgstr ""
+msgstr "Rc"
#: src/wx/content_menu.cc:54 src/wx/film_editor.cc:284
#: src/wx/editable_list.h:66
msgstr "Taglio a destra"
#: src/wx/audio_mapping_view.cc:300
-#, fuzzy
msgid "Rs"
-msgstr "s"
+msgstr "Rs"
#: src/wx/film_editor.cc:223
msgid "SMPTE"
#: src/wx/audio_mapping_view.cc:308
msgid "VI"
-msgstr ""
+msgstr "VI"
#: src/wx/video_panel.cc:67
msgid "Video"
#: src/wx/audio_mapping_view.cc:320
msgid "BsL"
-msgstr ""
+msgstr "BsL"
#: src/wx/audio_mapping_view.cc:324
msgid "BsR"
-msgstr ""
+msgstr "BsR"
#: src/wx/gain_calculator_dialog.cc:32
msgid "But I have to use fader"
#: src/wx/audio_mapping_view.cc:304
msgid "HI"
-msgstr ""
+msgstr "HI"
#: src/wx/hints_dialog.cc:26
msgid "Hints"
msgstr "V"
#: src/wx/audio_mapping_view.cc:312
-#, fuzzy
msgid "Lc"
-msgstr "V"
+msgstr "Vc"
#: src/wx/video_panel.cc:87
msgid "Left crop"
msgstr "Klassificering (ex. 15)"
#: src/wx/audio_mapping_view.cc:316
-#, fuzzy
msgid "Rc"
-msgstr "H"
+msgstr "Hc"
#: src/wx/content_menu.cc:54 src/wx/film_editor.cc:284
#: src/wx/editable_list.h:66
#: src/wx/audio_mapping_view.cc:308
msgid "VI"
-msgstr ""
+msgstr "VI"
#: src/wx/video_panel.cc:67
msgid "Video"
using std::ostream;
-namespace libdcp {
+namespace dcp {
ostream&
operator<< (ostream& s, dcp::Size const & t)