White space: player_video.{cc,h} reel_writer.{cc,h} maths_util.{cc,h} upmixer_{a,b}.{cc,h} upload_job.{cc,h}

12 files changed, 333 insertions, 333 deletions

diff --git a/src/lib/maths_util.cc b/src/lib/maths_util.cc
index 76681afb6..7fb3b74ee 100644
--- a/src/lib/maths_util.cc
+++ b/src/lib/maths_util.cc
@@ -24,21 +24,21 @@
 
 
 double
-db_to_linear (double db)
+db_to_linear(double db)
 {
 	return pow(10, db / 20);
 }
 
 
 double
-linear_to_db (double linear)
+linear_to_db(double linear)
 {
 	return 20 * log10(linear);
 }
 
 
 float
-logarithmic_fade_in_curve (float t)
+logarithmic_fade_in_curve(float t)
 {
 	auto const c = clamp(t, 0.0f, 1.0f);
 	return std::exp(2 * (c - 1)) * c;
@@ -46,7 +46,7 @@ logarithmic_fade_in_curve (float t)
 
 
 float
-logarithmic_fade_out_curve (float t)
+logarithmic_fade_out_curve(float t)
 {
 	auto const c = clamp(t, 0.0f, 1.0f);
 	return std::exp(-2 * c) * (1 - c);
diff --git a/src/lib/maths_util.h b/src/lib/maths_util.h
index 24c4b547f..9b3cb188a 100644
--- a/src/lib/maths_util.h
+++ b/src/lib/maths_util.h
@@ -27,15 +27,15 @@
 #endif
 
 
-extern double db_to_linear (double db);
-extern double linear_to_db (double linear);
+extern double db_to_linear(double db);
+extern double linear_to_db(double linear);
 
 /** @return linear gain according to a logarithmic curve, for fading in.
  *  t < 0:       linear gain of 0
  *  0 >= t >= 1: logarithmic fade in curve
  *  t > 1:       linear gain of 1
  */
-extern float logarithmic_fade_in_curve (float t);
+extern float logarithmic_fade_in_curve(float t);
 
 
 /** @return linear gain according to a logarithmic curve, for fading out.
@@ -43,11 +43,11 @@ extern float logarithmic_fade_in_curve (float t);
  *  0 >= t >= 1: logarithmic fade out curve
  *  t < 0:       linear gain of 1
  */
-extern float logarithmic_fade_out_curve (float t);
+extern float logarithmic_fade_out_curve(float t);
 
 
 template <class T>
-T clamp (T val, T minimum, T maximum)
+T clamp(T val, T minimum, T maximum)
 {
 	return std::max(std::min(val, maximum), minimum);
 }
diff --git a/src/lib/player_video.cc b/src/lib/player_video.cc
index 05538b845..b304d60df 100644
--- a/src/lib/player_video.cc
+++ b/src/lib/player_video.cc
@@ -47,7 +47,7 @@ using dcp::Data;
 using namespace dcpomatic;
 
 
-PlayerVideo::PlayerVideo (
+PlayerVideo::PlayerVideo(
 	shared_ptr<const ImageProxy> in,
 	Crop crop,
 	boost::optional<double> fade,
@@ -61,55 +61,55 @@ PlayerVideo::PlayerVideo (
 	optional<ContentTime> video_time,
 	bool error
 	)
-	: _in (in)
-	, _crop (crop)
-	, _fade (fade)
-	, _inter_size (inter_size)
-	, _out_size (out_size)
-	, _eyes (eyes)
-	, _part (part)
-	, _colour_conversion (colour_conversion)
-	, _video_range (video_range)
-	, _content (content)
+	: _in(in)
+	, _crop(crop)
+	, _fade(fade)
+	, _inter_size(inter_size)
+	, _out_size(out_size)
+	, _eyes(eyes)
+	, _part(part)
+	, _colour_conversion(colour_conversion)
+	, _video_range(video_range)
+	, _content(content)
 	, _video_time(video_time)
-	, _error (error)
+	, _error(error)
 {
 
 }
 
 
-PlayerVideo::PlayerVideo (shared_ptr<cxml::Node> node, shared_ptr<Socket> socket)
+PlayerVideo::PlayerVideo(shared_ptr<cxml::Node> node, shared_ptr<Socket> socket)
 {
-	_crop = Crop (node);
-	_fade = node->optional_number_child<double> ("Fade");
+	_crop = Crop(node);
+	_fade = node->optional_number_child<double>("Fade");
 
-	_inter_size = dcp::Size (node->number_child<int> ("InterWidth"), node->number_child<int> ("InterHeight"));
-	_out_size = dcp::Size (node->number_child<int> ("OutWidth"), node->number_child<int> ("OutHeight"));
+	_inter_size = dcp::Size(node->number_child<int>("InterWidth"), node->number_child<int>("InterHeight"));
+	_out_size = dcp::Size(node->number_child<int>("OutWidth"), node->number_child<int>("OutHeight"));
 	_eyes = static_cast<Eyes>(node->number_child<int>("Eyes"));
 	_part = static_cast<Part>(node->number_child<int>("Part"));
 	_video_range = static_cast<VideoRange>(node->number_child<int>("VideoRange"));
-	_error = node->optional_bool_child("Error").get_value_or (false);
+	_error = node->optional_bool_child("Error").get_value_or(false);
 
 	/* Assume that the ColourConversion uses the current state version */
-	_colour_conversion = ColourConversion::from_xml (node, Film::current_state_version);
+	_colour_conversion = ColourConversion::from_xml(node, Film::current_state_version);
 
-	_in = image_proxy_factory (node->node_child("In"), socket);
+	_in = image_proxy_factory(node->node_child("In"), socket);
 
 	if (node->optional_number_child<int>("SubtitleX")) {
 
-		auto image = make_shared<Image> (
+		auto image = make_shared<Image>(
 			AV_PIX_FMT_BGRA, dcp::Size(node->number_child<int>("SubtitleWidth"), node->number_child<int>("SubtitleHeight")), Image::Alignment::PADDED
 			);
 
-		image->read_from_socket (socket);
+		image->read_from_socket(socket);
 
-		_text = PositionImage (image, Position<int>(node->number_child<int>("SubtitleX"), node->number_child<int>("SubtitleY")));
+		_text = PositionImage(image, Position<int>(node->number_child<int>("SubtitleX"), node->number_child<int>("SubtitleY")));
 	}
 }
 
 
 void
-PlayerVideo::set_text (PositionImage image)
+PlayerVideo::set_text(PositionImage image)
 {
 	_text = image;
 }
@@ -120,16 +120,16 @@ PlayerVideo::image(AVPixelFormat pixel_format, VideoRange video_range, bool fast
 {
 	/* XXX: this assumes that image() and prepare() are only ever called with the same parameters (except crop, inter size, out size, fade) */
 
-	boost::mutex::scoped_lock lm (_mutex);
+	boost::mutex::scoped_lock lm(_mutex);
 	if (!_image || _crop != _image_crop || _inter_size != _image_inter_size || _out_size != _image_out_size || _fade != _image_fade) {
-		make_image (pixel_format, video_range, fast);
+		make_image(pixel_format, video_range, fast);
 	}
 	return _image;
 }
 
 
 shared_ptr<const Image>
-PlayerVideo::raw_image () const
+PlayerVideo::raw_image() const
 {
 	return _in->image(Image::Alignment::COMPACT, _inter_size).image;
 }
@@ -147,7 +147,7 @@ PlayerVideo::make_image(AVPixelFormat pixel_format, VideoRange video_range, bool
 	_image_out_size = _out_size;
 	_image_fade = _fade;
 
-	auto prox = _in->image (Image::Alignment::PADDED, _inter_size);
+	auto prox = _in->image(Image::Alignment::PADDED, _inter_size);
 	_error = prox.error;
 
 	auto total_crop = _crop;
@@ -182,16 +182,16 @@ PlayerVideo::make_image(AVPixelFormat pixel_format, VideoRange video_range, bool
 		yuv_to_rgb = _colour_conversion.get().yuv_to_rgb();
 	}
 
-	_image = prox.image->crop_scale_window (
+	_image = prox.image->crop_scale_window(
 		total_crop, _inter_size, _out_size, yuv_to_rgb, _video_range, pixel_format, video_range, Image::Alignment::COMPACT, fast
 		);
 
 	if (_text) {
-		_image->alpha_blend (_text->image, _text->position);
+		_image->alpha_blend(_text->image, _text->position);
 	}
 
 	if (_fade) {
-		_image->fade (_fade.get ());
+		_image->fade(_fade.get());
 	}
 }
 
@@ -225,21 +225,21 @@ PlayerVideo::add_metadata(xmlpp::Element* element) const
 
 
 void
-PlayerVideo::write_to_socket (shared_ptr<Socket> socket) const
+PlayerVideo::write_to_socket(shared_ptr<Socket> socket) const
 {
-	_in->write_to_socket (socket);
+	_in->write_to_socket(socket);
 	if (_text) {
-		_text->image->write_to_socket (socket);
+		_text->image->write_to_socket(socket);
 	}
 }
 
 
 bool
-PlayerVideo::has_j2k () const
+PlayerVideo::has_j2k() const
 {
 	/* XXX: maybe other things */
 
-	auto j2k = dynamic_pointer_cast<const J2KImageProxy> (_in);
+	auto j2k = dynamic_pointer_cast<const J2KImageProxy>(_in);
 	if (!j2k) {
 		return false;
 	}
@@ -249,24 +249,24 @@ PlayerVideo::has_j2k () const
 
 
 shared_ptr<const dcp::Data>
-PlayerVideo::j2k () const
+PlayerVideo::j2k() const
 {
-	auto j2k = dynamic_pointer_cast<const J2KImageProxy> (_in);
-	DCPOMATIC_ASSERT (j2k);
-	return j2k->j2k ();
+	auto j2k = dynamic_pointer_cast<const J2KImageProxy>(_in);
+	DCPOMATIC_ASSERT(j2k);
+	return j2k->j2k();
 }
 
 
 Position<int>
-PlayerVideo::inter_position () const
+PlayerVideo::inter_position() const
 {
-	return Position<int> ((_out_size.width - _inter_size.width) / 2, (_out_size.height - _inter_size.height) / 2);
+	return Position<int>((_out_size.width - _inter_size.width) / 2, (_out_size.height - _inter_size.height) / 2);
 }
 
 
 /** @return true if this PlayerVideo is definitely the same as another, false if it is probably not */
 bool
-PlayerVideo::same (shared_ptr<const PlayerVideo> other) const
+PlayerVideo::same(shared_ptr<const PlayerVideo> other) const
 {
 	if (_crop != other->_crop ||
 	    _fade != other->_fade ||
@@ -284,30 +284,30 @@ PlayerVideo::same (shared_ptr<const PlayerVideo> other) const
 		return false;
 	}
 
-	if (_text && other->_text && !_text->same (other->_text.get ())) {
+	if (_text && other->_text && !_text->same(other->_text.get())) {
 		/* They both have texts but they are different */
 		return false;
 	}
 
 	/* Now neither has subtitles */
 
-	return _in->same (other->_in);
+	return _in->same(other->_in);
 }
 
 
 void
 PlayerVideo::prepare(AVPixelFormat pixel_format, VideoRange video_range, Image::Alignment alignment, bool fast, bool proxy_only)
 {
-	_in->prepare (alignment, _inter_size);
-	boost::mutex::scoped_lock lm (_mutex);
+	_in->prepare(alignment, _inter_size);
+	boost::mutex::scoped_lock lm(_mutex);
 	if (!_image && !proxy_only) {
-		make_image (pixel_format, video_range, fast);
+		make_image(pixel_format, video_range, fast);
 	}
 }
 
 
 size_t
-PlayerVideo::memory_used () const
+PlayerVideo::memory_used() const
 {
 	return _in->memory_used();
 }
@@ -315,7 +315,7 @@ PlayerVideo::memory_used () const
 
 /** @return Shallow copy of this; _in and _text are shared between the original and the copy */
 shared_ptr<PlayerVideo>
-PlayerVideo::shallow_copy () const
+PlayerVideo::shallow_copy() const
 {
 	return std::make_shared<PlayerVideo>(
 		_in,
@@ -338,7 +338,7 @@ PlayerVideo::shallow_copy () const
  *  @return true if this was possible, false if not.
  */
 bool
-PlayerVideo::reset_metadata (shared_ptr<const Film> film, dcp::Size player_video_container_size)
+PlayerVideo::reset_metadata(shared_ptr<const Film> film, dcp::Size player_video_container_size)
 {
 	auto content = _content.lock();
 	if (!content || !_video_time) {
diff --git a/src/lib/player_video.h b/src/lib/player_video.h
index c3ea9351b..df0ef6d15 100644
--- a/src/lib/player_video.h
+++ b/src/lib/player_video.h
@@ -48,7 +48,7 @@ class Socket;
 class PlayerVideo
 {
 public:
-	PlayerVideo (
+	PlayerVideo(
 		std::shared_ptr<const ImageProxy> image,
 		Crop crop,
 		boost::optional<double> fade,
@@ -63,51 +63,51 @@ public:
 		bool error
 		);
 
-	PlayerVideo (std::shared_ptr<cxml::Node>, std::shared_ptr<Socket>);
+	PlayerVideo(std::shared_ptr<cxml::Node>, std::shared_ptr<Socket>);
 
-	PlayerVideo (PlayerVideo const&) = delete;
-	PlayerVideo& operator= (PlayerVideo const&) = delete;
+	PlayerVideo(PlayerVideo const&) = delete;
+	PlayerVideo& operator=(PlayerVideo const&) = delete;
 
-	std::shared_ptr<PlayerVideo> shallow_copy () const;
+	std::shared_ptr<PlayerVideo> shallow_copy() const;
 
-	void set_text (PositionImage);
-	boost::optional<PositionImage> text () const {
+	void set_text(PositionImage);
+	boost::optional<PositionImage> text() const {
 		return _text;
 	}
 
 	void prepare(AVPixelFormat pixel_format, VideoRange video_range, Image::Alignment alignment, bool fast, bool proxy_only);
 	std::shared_ptr<Image> image(AVPixelFormat pixel_format, VideoRange video_range, bool fast) const;
-	std::shared_ptr<const Image> raw_image () const;
+	std::shared_ptr<const Image> raw_image() const;
 
 	void add_metadata(xmlpp::Element* element) const;
-	void write_to_socket (std::shared_ptr<Socket> socket) const;
+	void write_to_socket(std::shared_ptr<Socket> socket) const;
 
-	bool reset_metadata (std::shared_ptr<const Film> film, dcp::Size player_video_container_size);
+	bool reset_metadata(std::shared_ptr<const Film> film, dcp::Size player_video_container_size);
 
-	bool has_j2k () const;
-	std::shared_ptr<const dcp::Data> j2k () const;
+	bool has_j2k() const;
+	std::shared_ptr<const dcp::Data> j2k() const;
 
-	Eyes eyes () const {
+	Eyes eyes() const {
 		return _eyes;
 	}
 
-	void set_eyes (Eyes e) {
+	void set_eyes(Eyes e) {
 		_eyes = e;
 	}
 
-	boost::optional<ColourConversion> colour_conversion () const {
+	boost::optional<ColourConversion> colour_conversion() const {
 		return _colour_conversion;
 	}
 
 	/** @return Position of the content within the overall image once it has been scaled up */
-	Position<int> inter_position () const;
+	Position<int> inter_position() const;
 
 	/** @return Size of the content within the overall image once it has been scaled up */
-	dcp::Size inter_size () const {
+	dcp::Size inter_size() const {
 		return _inter_size;
 	}
 
-	dcp::Size out_size () const {
+	dcp::Size out_size() const {
 		return _out_size;
 	}
 
@@ -115,15 +115,15 @@ public:
 		return _crop;
 	}
 
-	bool same (std::shared_ptr<const PlayerVideo> other) const;
+	bool same(std::shared_ptr<const PlayerVideo> other) const;
 
-	size_t memory_used () const;
+	size_t memory_used() const;
 
-	std::weak_ptr<Content> content () const {
+	std::weak_ptr<Content> content() const {
 		return _content;
 	}
 
-	bool error () const {
+	bool error() const {
 		return _error;
 	}
 
diff --git a/src/lib/reel_writer.cc b/src/lib/reel_writer.cc
index edc3b0d7b..bd326e853 100644
--- a/src/lib/reel_writer.cc
+++ b/src/lib/reel_writer.cc
@@ -81,18 +81,18 @@ using namespace dcpomatic;
 
 
 static dcp::MXFMetadata
-mxf_metadata ()
+mxf_metadata()
 {
 	dcp::MXFMetadata meta;
 	auto config = Config::instance();
 	if (!config->dcp_company_name().empty()) {
-		meta.company_name = config->dcp_company_name ();
+		meta.company_name = config->dcp_company_name();
 	}
 	if (!config->dcp_product_name().empty()) {
-		meta.product_name = config->dcp_product_name ();
+		meta.product_name = config->dcp_product_name();
 	}
 	if (!config->dcp_product_version().empty()) {
-		meta.product_version = config->dcp_product_version ();
+		meta.product_version = config->dcp_product_version();
 	}
 	return meta;
 }
@@ -103,17 +103,17 @@ mxf_metadata ()
  *  (no picture nor sound) and not give errors in that case.  This is used by the hints system to check the potential sizes of
  *  subtitle / closed caption files.
  */
-ReelWriter::ReelWriter (
+ReelWriter::ReelWriter(
 	weak_ptr<const Film> weak_film, DCPTimePeriod period, shared_ptr<Job> job, int reel_index, int reel_count, bool text_only, boost::filesystem::path output_dir
 	)
 	: WeakConstFilm(weak_film)
 	, _output_dir(std::move(output_dir))
-	, _period (period)
-	, _reel_index (reel_index)
-	, _reel_count (reel_count)
-	, _content_summary (film()->content_summary(period))
-	, _job (job)
-	, _text_only (text_only)
+	, _period(period)
+	, _reel_index(reel_index)
+	, _reel_count(reel_count)
+	, _content_summary(film()->content_summary(period))
+	, _job(job)
+	, _text_only(text_only)
 	, _info_file(film()->info_file(period), dcp::filesystem::exists(film()->info_file(period)) ? "r+b" : "wb")
 	, _font_metrics(film()->frame_size().height)
 {
@@ -209,7 +209,7 @@ ReelWriter::ReelWriter (
 
 	if (film()->audio_channels()) {
 		auto lang = film()->audio_language();
-		_sound_asset = make_shared<dcp::SoundAsset> (
+		_sound_asset = make_shared<dcp::SoundAsset>(
 			dcp::Fraction(film()->video_frame_rate(), 1),
 			film()->audio_frame_rate(),
 			film()->audio_channels(),
@@ -217,13 +217,13 @@ ReelWriter::ReelWriter (
 			standard
 			);
 
-		_sound_asset->set_metadata (mxf_metadata());
+		_sound_asset->set_metadata(mxf_metadata());
 
 		if (film()->encrypted()) {
-			_sound_asset->set_key (film()->key());
+			_sound_asset->set_key(film()->key());
 		}
 
-		DCPOMATIC_ASSERT (film()->directory());
+		DCPOMATIC_ASSERT(film()->directory());
 
 		std::vector<dcp::Channel> extra_active_channels;
 		for (auto channel: std::vector<dcp::Channel>{dcp::Channel::HI, dcp::Channel::VI, dcp::Channel::BSL, dcp::Channel::BSR}) {
@@ -235,8 +235,8 @@ ReelWriter::ReelWriter (
 		/* Write the sound asset into the film directory so that we leave the creation
 		   of the DCP directory until the last minute.
 		*/
-		_sound_asset_writer = _sound_asset->start_write (
-			film()->directory().get() / audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary),
+		_sound_asset_writer = _sound_asset->start_write(
+			film()->directory().get() / audio_asset_filename(_sound_asset, _reel_index, _reel_count, _content_summary),
 			extra_active_channels,
 			film()->contains_atmos_content() ? dcp::SoundAsset::AtmosSync::ENABLED : dcp::SoundAsset::AtmosSync::DISABLED,
 			film()->limit_to_smpte_bv20() ? dcp::SoundAsset::MCASubDescriptors::DISABLED : dcp::SoundAsset::MCASubDescriptors::ENABLED
@@ -246,21 +246,21 @@ ReelWriter::ReelWriter (
 
 
 Frame
-ReelWriter::check_existing_picture_asset (boost::filesystem::path asset)
+ReelWriter::check_existing_picture_asset(boost::filesystem::path asset)
 {
-	auto job = _job.lock ();
+	auto job = _job.lock();
 
 	if (job) {
-		job->sub (_("Checking existing image data"));
+		job->sub(_("Checking existing image data"));
 	}
 
 	/* Try to open the existing asset */
 	dcp::File asset_file(asset, "rb");
 	if (!asset_file) {
-		LOG_GENERAL ("Could not open existing asset at %1 (errno=%2)", asset.string(), errno);
+		LOG_GENERAL("Could not open existing asset at %1 (errno=%2)", asset.string(), errno);
 		return 0;
 	} else {
-		LOG_GENERAL ("Opened existing asset at %1", asset.string());
+		LOG_GENERAL("Opened existing asset at %1", asset.string());
 	}
 
 	/* Offset of the last dcp::FrameInfo in the info file */
@@ -286,14 +286,14 @@ ReelWriter::check_existing_picture_asset (boost::filesystem::path asset)
 		++first_nonexistent_frame;
 	}
 
-	LOG_GENERAL ("Proceeding with first nonexistent frame %1", first_nonexistent_frame);
+	LOG_GENERAL("Proceeding with first nonexistent frame %1", first_nonexistent_frame);
 
 	return first_nonexistent_frame;
 }
 
 
 void
-ReelWriter::write (shared_ptr<const Data> encoded, Frame frame, Eyes eyes)
+ReelWriter::write(shared_ptr<const Data> encoded, Frame frame, Eyes eyes)
 {
 	if (!_j2k_picture_asset_writer) {
 		/* We're not writing any data */
@@ -307,18 +307,18 @@ ReelWriter::write (shared_ptr<const Data> encoded, Frame frame, Eyes eyes)
 
 
 void
-ReelWriter::write (shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata)
+ReelWriter::write(shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata)
 {
 	if (!_atmos_asset) {
-		_atmos_asset = metadata.create (dcp::Fraction(film()->video_frame_rate(), 1));
+		_atmos_asset = metadata.create(dcp::Fraction(film()->video_frame_rate(), 1));
 		if (film()->encrypted()) {
 			_atmos_asset->set_key(film()->key());
 		}
-		_atmos_asset_writer = _atmos_asset->start_write (
-			film()->directory().get() / atmos_asset_filename (_atmos_asset, _reel_index, _reel_count, _content_summary)
+		_atmos_asset_writer = _atmos_asset->start_write(
+			film()->directory().get() / atmos_asset_filename(_atmos_asset, _reel_index, _reel_count, _content_summary)
 			);
 	}
-	_atmos_asset_writer->write (atmos);
+	_atmos_asset_writer->write(atmos);
 }
 
 
@@ -342,7 +342,7 @@ ReelWriter::fake_write(Frame frame, Eyes eyes)
 
 
 void
-ReelWriter::repeat_write (Frame frame, Eyes eyes)
+ReelWriter::repeat_write(Frame frame, Eyes eyes)
 {
 	if (!_j2k_picture_asset_writer) {
 		/* We're not writing any data */
@@ -355,7 +355,7 @@ ReelWriter::repeat_write (Frame frame, Eyes eyes)
 
 
 void
-ReelWriter::finish (boost::filesystem::path output_dcp)
+ReelWriter::finish(boost::filesystem::path output_dcp)
 {
 	if (_j2k_picture_asset_writer && !_j2k_picture_asset_writer->finalize()) {
 		/* Nothing was written to the J2K picture asset */
@@ -369,43 +369,43 @@ ReelWriter::finish (boost::filesystem::path output_dcp)
 		_mpeg2_picture_asset.reset();
 	}
 
-	if (_sound_asset_writer && !_sound_asset_writer->finalize ()) {
+	if (_sound_asset_writer && !_sound_asset_writer->finalize()) {
 		/* Nothing was written to the sound asset */
-		_sound_asset.reset ();
+		_sound_asset.reset();
 	}
 
 	/* Move the audio asset into the DCP */
 	if (_sound_asset) {
 		boost::filesystem::path audio_to = output_dcp;
-		auto const aaf = audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary);
+		auto const aaf = audio_asset_filename(_sound_asset, _reel_index, _reel_count, _content_summary);
 		audio_to /= aaf;
 
 		boost::system::error_code ec;
 		dcp::filesystem::rename(film()->file(aaf), audio_to, ec);
 		if (ec) {
-			throw FileError (
+			throw FileError(
 				String::compose(_("could not move audio asset into the DCP (%1)"), error_details(ec)), aaf
 				);
 		}
 
-		_sound_asset->set_file (audio_to);
+		_sound_asset->set_file(audio_to);
 	}
 
 	if (_atmos_asset) {
-		_atmos_asset_writer->finalize ();
+		_atmos_asset_writer->finalize();
 		boost::filesystem::path atmos_to = output_dcp;
-		auto const aaf = atmos_asset_filename (_atmos_asset, _reel_index, _reel_count, _content_summary);
+		auto const aaf = atmos_asset_filename(_atmos_asset, _reel_index, _reel_count, _content_summary);
 		atmos_to /= aaf;
 
 		boost::system::error_code ec;
 		dcp::filesystem::rename(film()->file(aaf), atmos_to, ec);
 		if (ec) {
-			throw FileError (
+			throw FileError(
 				String::compose(_("could not move atmos asset into the DCP (%1)"), error_details(ec)), aaf
 				);
 		}
 
-		_atmos_asset->set_file (atmos_to);
+		_atmos_asset->set_file(atmos_to);
 	}
 }
 
@@ -415,7 +415,7 @@ ReelWriter::finish (boost::filesystem::path output_dcp)
  */
 template <class Interop, class SMPTE, class Result>
 shared_ptr<Result>
-maybe_add_text (
+maybe_add_text(
 	shared_ptr<dcp::TextAsset> asset,
 	dcp::TextType type,
 	int64_t picture_duration,
@@ -436,10 +436,10 @@ maybe_add_text (
 
 	if (asset) {
 		if (auto interop = dynamic_pointer_cast<dcp::InteropTextAsset>(asset)) {
-			auto directory = output_dcp / interop->id ();
+			auto directory = output_dcp / interop->id();
 			dcp::filesystem::create_directories(directory);
-			interop->write (directory / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".xml"));
-			reel_asset = make_shared<Interop> (
+			interop->write(directory / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".xml"));
+			reel_asset = make_shared<Interop>(
 				type,
 				interop,
 				dcp::Fraction(film->video_frame_rate(), 1),
@@ -453,10 +453,10 @@ maybe_add_text (
 			   just interested in its presentation length.
 			*/
 			smpte->set_intrinsic_duration(picture_duration);
-			smpte->write (
+			smpte->write(
 				output_dcp / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".mxf")
 				);
-			reel_asset = make_shared<SMPTE> (
+			reel_asset = make_shared<SMPTE>(
 				type,
 				smpte,
 				dcp::Fraction(film->video_frame_rate(), 1),
@@ -468,12 +468,12 @@ maybe_add_text (
 	} else {
 		/* We don't have a subtitle asset of our own; hopefully we have one to reference */
 		for (auto j: refs) {
-			auto k = dynamic_pointer_cast<Result> (j.asset);
+			auto k = dynamic_pointer_cast<Result>(j.asset);
 			if (k && j.period == period) {
 				reel_asset = k;
 				/* If we have a hash for this asset in the CPL, assume that it is correct */
 				if (k->hash()) {
-					k->asset_ref()->set_hash (k->hash().get());
+					k->asset_ref()->set_hash(k->hash().get());
 				}
 			}
 		}
@@ -481,12 +481,12 @@ maybe_add_text (
 
 	if (reel_asset) {
 		if (!text_only && reel_asset->actual_duration() != period_duration) {
-			throw ProgrammingError (
+			throw ProgrammingError(
 				__FILE__, __LINE__,
-				String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
+				String::compose("%1 vs %2", reel_asset->actual_duration(), period_duration)
 				);
 		}
-		reel->add (reel_asset);
+		reel->add(reel_asset);
 	}
 
 	return reel_asset;
@@ -494,7 +494,7 @@ maybe_add_text (
 
 
 shared_ptr<dcp::ReelPictureAsset>
-ReelWriter::create_reel_picture (shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
+ReelWriter::create_reel_picture(shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
 {
 	shared_ptr<dcp::ReelPictureAsset> reel_asset;
 
@@ -510,12 +510,12 @@ ReelWriter::create_reel_picture (shared_ptr<dcp::Reel> reel, list<ReferencedReel
 	} else if (_mpeg2_picture_asset) {
 		reel_asset = make_shared<dcp::ReelMonoPictureAsset>(_mpeg2_picture_asset, 0);
 	} else {
-		LOG_GENERAL ("no picture asset of our own; look through %1", refs.size());
+		LOG_GENERAL("no picture asset of our own; look through %1", refs.size());
 		/* We don't have a picture asset of our own; hopefully we have one to reference */
 		for (auto j: refs) {
-			auto k = dynamic_pointer_cast<dcp::ReelPictureAsset> (j.asset);
+			auto k = dynamic_pointer_cast<dcp::ReelPictureAsset>(j.asset);
 			if (k) {
-				LOG_GENERAL ("candidate picture asset period is %1-%2", j.period.from.get(), j.period.to.get());
+				LOG_GENERAL("candidate picture asset period is %1-%2", j.period.from.get(), j.period.to.get());
 			}
 			if (k && j.period == _period) {
 				reel_asset = k;
@@ -525,18 +525,18 @@ ReelWriter::create_reel_picture (shared_ptr<dcp::Reel> reel, list<ReferencedReel
 
 	Frame const period_duration = _period.duration().frames_round(film()->video_frame_rate());
 
-	DCPOMATIC_ASSERT (reel_asset);
+	DCPOMATIC_ASSERT(reel_asset);
 	if (reel_asset->duration() != period_duration) {
-		throw ProgrammingError (
+		throw ProgrammingError(
 			__FILE__, __LINE__,
-			String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
+			String::compose("%1 vs %2", reel_asset->actual_duration(), period_duration)
 			);
 	}
-	reel->add (reel_asset);
+	reel->add(reel_asset);
 
 	/* If we have a hash for this asset in the CPL, assume that it is correct */
 	if (reel_asset->hash()) {
-		reel_asset->asset_ref()->set_hash (reel_asset->hash().get());
+		reel_asset->asset_ref()->set_hash(reel_asset->hash().get());
 	}
 
 	return reel_asset;
@@ -544,7 +544,7 @@ ReelWriter::create_reel_picture (shared_ptr<dcp::Reel> reel, list<ReferencedReel
 
 
 void
-ReelWriter::create_reel_sound (shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
+ReelWriter::create_reel_sound(shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
 {
 	shared_ptr<dcp::ReelSoundAsset> reel_asset;
 
@@ -552,18 +552,18 @@ ReelWriter::create_reel_sound (shared_ptr<dcp::Reel> reel, list<ReferencedReelAs
 		/* We have made a sound asset of our own.  Put it into the reel */
 		reel_asset = make_shared<dcp::ReelSoundAsset>(_sound_asset, 0);
 	} else {
-		LOG_GENERAL ("no sound asset of our own; look through %1", refs.size());
+		LOG_GENERAL("no sound asset of our own; look through %1", refs.size());
 		/* We don't have a sound asset of our own; hopefully we have one to reference */
 		for (auto j: refs) {
-			auto k = dynamic_pointer_cast<dcp::ReelSoundAsset> (j.asset);
+			auto k = dynamic_pointer_cast<dcp::ReelSoundAsset>(j.asset);
 			if (k) {
-				LOG_GENERAL ("candidate sound asset period is %1-%2", j.period.from.get(), j.period.to.get());
+				LOG_GENERAL("candidate sound asset period is %1-%2", j.period.from.get(), j.period.to.get());
 			}
 			if (k && j.period == _period) {
 				reel_asset = k;
 				/* If we have a hash for this asset in the CPL, assume that it is correct */
 				if (k->hash()) {
-					k->asset_ref()->set_hash (k->hash().get());
+					k->asset_ref()->set_hash(k->hash().get());
 				}
 			}
 		}
@@ -571,27 +571,27 @@ ReelWriter::create_reel_sound (shared_ptr<dcp::Reel> reel, list<ReferencedReelAs
 
 	auto const period_duration = _period.duration().frames_round(film()->video_frame_rate());
 
-	DCPOMATIC_ASSERT (reel_asset);
+	DCPOMATIC_ASSERT(reel_asset);
 	if (reel_asset->actual_duration() != period_duration) {
-		LOG_ERROR (
+		LOG_ERROR(
 			"Reel sound asset has length %1 but reel period is %2",
 			reel_asset->actual_duration(),
 			period_duration
 			);
 		if (reel_asset->actual_duration() != period_duration) {
-			throw ProgrammingError (
+			throw ProgrammingError(
 				__FILE__, __LINE__,
-				String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
+				String::compose("%1 vs %2", reel_asset->actual_duration(), period_duration)
 				);
 		}
 
 	}
-	reel->add (reel_asset);
+	reel->add(reel_asset);
 }
 
 
 void
-ReelWriter::create_reel_text (
+ReelWriter::create_reel_text(
 	shared_ptr<dcp::Reel> reel,
 	list<ReferencedReelAsset> const & refs,
 	int64_t duration,
@@ -600,7 +600,7 @@ ReelWriter::create_reel_text (
 	set<DCPTextTrack> ensure_closed_captions
 	) const
 {
-	auto subtitle = maybe_add_text<dcp::ReelInteropTextAsset, dcp::ReelSMPTETextAsset, dcp::ReelTextAsset> (
+	auto subtitle = maybe_add_text<dcp::ReelInteropTextAsset, dcp::ReelSMPTETextAsset, dcp::ReelTextAsset>(
 		_subtitle_asset, dcp::TextType::OPEN_SUBTITLE, duration, reel, _reel_index, _reel_count, _content_summary, refs, film(), _period, output_dcp, _text_only
 		);
 
@@ -625,7 +625,7 @@ ReelWriter::create_reel_text (
 	if (subtitle) {
 		/* We have a subtitle asset that we either made or are referencing */
 		if (auto main_language = film()->open_text_languages().first) {
-			subtitle->set_language (*main_language);
+			subtitle->set_language(*main_language);
 		}
 	}
 
@@ -633,13 +633,13 @@ ReelWriter::create_reel_text (
 		auto a = maybe_add_text<dcp::ReelInteropTextAsset, dcp::ReelSMPTETextAsset, dcp::ReelTextAsset>(
 			i.second, dcp::TextType::CLOSED_CAPTION, duration, reel, _reel_index, _reel_count, _content_summary, refs, film(), _period, output_dcp, _text_only
 			);
-		DCPOMATIC_ASSERT (a);
-		a->set_annotation_text (i.first.name);
+		DCPOMATIC_ASSERT(a);
+		a->set_annotation_text(i.first.name);
 		if (i.first.language) {
-			a->set_language (i.first.language.get());
+			a->set_language(i.first.language.get());
 		}
 
-		ensure_closed_captions.erase (i.first);
+		ensure_closed_captions.erase(i.first);
 	}
 
 	/* Make empty tracks for anything we've been asked to ensure but that we haven't added */
@@ -658,17 +658,17 @@ ReelWriter::create_reel_text (
 			output_dcp,
 			_text_only
 			);
-		DCPOMATIC_ASSERT (a);
-		a->set_annotation_text (i.name);
+		DCPOMATIC_ASSERT(a);
+		a->set_annotation_text(i.name);
 		if (i.language) {
-			a->set_language (i.language.get());
+			a->set_language(i.language.get());
 		}
 	}
 }
 
 
 void
-ReelWriter::create_reel_markers (shared_ptr<dcp::Reel> reel) const
+ReelWriter::create_reel_markers(shared_ptr<dcp::Reel> reel) const
 {
 	auto markers = film()->markers();
 	film()->add_ffoc_lfoc(markers);
@@ -679,14 +679,14 @@ ReelWriter::create_reel_markers (shared_ptr<dcp::Reel> reel) const
 		}
 	}
 
-	if (!reel_markers.empty ()) {
+	if (!reel_markers.empty()) {
 		auto ma = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(film()->video_frame_rate(), 1), reel->duration());
 		for (auto const& i: reel_markers) {
 			DCPTime relative = i.second - _period.from;
-			auto hmsf = relative.split (film()->video_frame_rate());
-			ma->set (i.first, dcp::Time(hmsf.h, hmsf.m, hmsf.s, hmsf.f, film()->video_frame_rate()));
+			auto hmsf = relative.split(film()->video_frame_rate());
+			ma->set(i.first, dcp::Time(hmsf.h, hmsf.m, hmsf.s, hmsf.f, film()->video_frame_rate()));
 		}
-		reel->add (ma);
+		reel->add(ma);
 	}
 }
 
@@ -695,14 +695,14 @@ ReelWriter::create_reel_markers (shared_ptr<dcp::Reel> reel) const
  *  @param ensure_closed_captions make sure the reel has these closed caption tracks.
  */
 shared_ptr<dcp::Reel>
-ReelWriter::create_reel (
+ReelWriter::create_reel(
 	list<ReferencedReelAsset> const & refs,
 	boost::filesystem::path output_dcp,
 	bool ensure_subtitles,
 	set<DCPTextTrack> ensure_closed_captions
 	)
 {
-	LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
+	LOG_GENERAL("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
 
 	auto reel = make_shared<dcp::Reel>();
 
@@ -712,9 +712,9 @@ ReelWriter::create_reel (
 	 */
 	int64_t duration = 0;
 	if (!_text_only) {
-		auto reel_picture_asset = create_reel_picture (reel, refs);
-		duration = reel_picture_asset->actual_duration ();
-		create_reel_sound (reel, refs);
+		auto reel_picture_asset = create_reel_picture(reel, refs);
+		duration = reel_picture_asset->actual_duration();
+		create_reel_sound(reel, refs);
 		if (!film()->interop()) {
 			create_reel_markers(reel);
 		}
@@ -723,7 +723,7 @@ ReelWriter::create_reel (
 	create_reel_text(reel, refs, duration, output_dcp, ensure_subtitles, ensure_closed_captions);
 
 	if (_atmos_asset) {
-		reel->add (make_shared<dcp::ReelAtmosAsset>(_atmos_asset, 0));
+		reel->add(make_shared<dcp::ReelAtmosAsset>(_atmos_asset, 0));
 	}
 
 	return reel;
@@ -734,7 +734,7 @@ ReelWriter::create_reel (
  *  done, second parameter is the number of bytes in total.
  */
 void
-ReelWriter::calculate_digests(std::function<void (int64_t, int64_t)> set_progress)
+ReelWriter::calculate_digests(std::function<void(int64_t, int64_t)> set_progress)
 try
 {
 	vector<shared_ptr<const dcp::Asset>> assets;
@@ -773,26 +773,26 @@ try
 
 
 Frame
-ReelWriter::start () const
+ReelWriter::start() const
 {
-	return _period.from.frames_floor (film()->video_frame_rate());
+	return _period.from.frames_floor(film()->video_frame_rate());
 }
 
 
 void
-ReelWriter::write (shared_ptr<const AudioBuffers> audio)
+ReelWriter::write(shared_ptr<const AudioBuffers> audio)
 {
 	if (!_sound_asset_writer) {
 		return;
 	}
 
-	DCPOMATIC_ASSERT (audio);
+	DCPOMATIC_ASSERT(audio);
 	_sound_asset_writer->write(audio->data(), audio->channels(), audio->frames());
 }
 
 
 shared_ptr<dcp::TextAsset>
-ReelWriter::empty_text_asset (TextType type, optional<DCPTextTrack> track, bool with_dummy) const
+ReelWriter::empty_text_asset(TextType type, optional<DCPTextTrack> track, bool with_dummy) const
 {
 	shared_ptr<dcp::TextAsset> asset;
 	optional<string> font;
@@ -800,7 +800,7 @@ ReelWriter::empty_text_asset (TextType type, optional<DCPTextTrack> track, bool
 	auto lang = film()->open_text_languages();
 	if (film()->interop()) {
 		auto s = make_shared<dcp::InteropTextAsset>();
-		s->set_movie_title (film()->name());
+		s->set_movie_title(film()->name());
 		if (is_open(type)) {
 			s->set_language(lang.first ? lang.first->as_string() : "Unknown");
 		} else if (track->language) {
@@ -810,19 +810,19 @@ ReelWriter::empty_text_asset (TextType type, optional<DCPTextTrack> track, bool
 		asset = s;
 	} else {
 		auto s = make_shared<dcp::SMPTETextAsset>();
-		s->set_content_title_text (film()->name());
-		s->set_metadata (mxf_metadata());
+		s->set_content_title_text(film()->name());
+		s->set_metadata(mxf_metadata());
 		if (is_open(type) && lang.first) {
-			s->set_language (*lang.first);
+			s->set_language(*lang.first);
 		} else if (track && track->language) {
 			s->set_language(dcp::LanguageTag(track->language->as_string()));
 		}
-		s->set_edit_rate (dcp::Fraction (film()->video_frame_rate(), 1));
-		s->set_reel_number (_reel_index + 1);
-		s->set_time_code_rate (film()->video_frame_rate());
-		s->set_start_time (dcp::Time ());
+		s->set_edit_rate(dcp::Fraction(film()->video_frame_rate(), 1));
+		s->set_reel_number(_reel_index + 1);
+		s->set_time_code_rate(film()->video_frame_rate());
+		s->set_start_time(dcp::Time());
 		if (film()->encrypted()) {
-			s->set_key (film()->key());
+			s->set_key(film()->key());
 		}
 		asset = s;
 	}
@@ -911,15 +911,15 @@ ReelWriter::write(PlayerText subs, TextType type, optional<DCPTextTrack> track,
 	case TextType::CLOSED_CAPTION:
 	case TextType::CLOSED_SUBTITLE:
 		/* Similarly it is advised by Deluxe not to use ClosedSubtitle */
-		DCPOMATIC_ASSERT (track);
+		DCPOMATIC_ASSERT(track);
 		asset = _closed_caption_assets[*track];
 		break;
 	default:
-		DCPOMATIC_ASSERT (false);
+		DCPOMATIC_ASSERT(false);
 	}
 
 	if (!asset) {
-		asset = empty_text_asset (type, track, false);
+		asset = empty_text_asset(type, track, false);
 	}
 
 	switch (type) {
@@ -929,19 +929,19 @@ ReelWriter::write(PlayerText subs, TextType type, optional<DCPTextTrack> track,
 		break;
 	case TextType::CLOSED_CAPTION:
 	case TextType::CLOSED_SUBTITLE:
-		DCPOMATIC_ASSERT (track);
+		DCPOMATIC_ASSERT(track);
 		_closed_caption_assets[*track] = asset;
 		break;
 	default:
-		DCPOMATIC_ASSERT (false);
+		DCPOMATIC_ASSERT(false);
 	}
 
 	/* timecode rate for subtitles we emit; we might as well stick to ms accuracy here, I think */
 	auto const tcr = 1000;
 
 	for (auto i: subs.string) {
-		i.set_in  (dcp::Time(period.from.seconds() - _period.from.seconds(), tcr));
-		i.set_out (dcp::Time(period.to.seconds() - _period.from.seconds(), tcr));
+		i.set_in(dcp::Time(period.from.seconds() - _period.from.seconds(), tcr));
+		i.set_out(dcp::Time(period.to.seconds() - _period.from.seconds(), tcr));
 		i.set_v_position(convert_vertical_position(i, film()->interop() ? dcp::SubtitleStandard::INTEROP : dcp::SubtitleStandard::SMPTE_2014));
 		auto sub = make_shared<dcp::TextString>(i);
 		/* i.font is a shared_ptr<Font> which uniquely identifies the font we want,
@@ -959,7 +959,7 @@ ReelWriter::write(PlayerText subs, TextType type, optional<DCPTextTrack> track,
 	}
 
 	for (auto i: subs.bitmap) {
-		asset->add (
+		asset->add(
 			std::make_shared<dcp::TextImage>(
 				image_as_png(i.image),
 				dcp::Time(period.from.seconds() - _period.from.seconds(), tcr),
@@ -975,7 +975,7 @@ ReelWriter::write(PlayerText subs, TextType type, optional<DCPTextTrack> track,
 bool
 ReelWriter::existing_picture_frame_ok(dcp::File& asset_file, Frame frame)
 {
-	LOG_GENERAL ("Checking existing picture frame %1", frame);
+	LOG_GENERAL("Checking existing picture frame %1", frame);
 
 	/* Read the data from the info file; for 3D we just check the left
 	   frames until we find a good one.
@@ -986,18 +986,18 @@ ReelWriter::existing_picture_frame_ok(dcp::File& asset_file, Frame frame)
 
 	/* Read the data from the asset and hash it */
 	asset_file.seek(info.offset, SEEK_SET);
-	ArrayData data (info.size);
+	ArrayData data(info.size);
 	size_t const read = asset_file.read(data.data(), 1, data.size());
-	LOG_GENERAL ("Read %1 bytes of asset data; wanted %2", read, info.size);
-	if (read != static_cast<size_t> (data.size ())) {
-		LOG_GENERAL ("Existing frame %1 is incomplete", frame);
+	LOG_GENERAL("Read %1 bytes of asset data; wanted %2", read, info.size);
+	if (read != static_cast<size_t>(data.size())) {
+		LOG_GENERAL("Existing frame %1 is incomplete", frame);
 		ok = false;
 	} else {
 		Digester digester;
-		digester.add (data.data(), data.size());
-		LOG_GENERAL ("Hash %1 vs %2", digester.get(), info.hash);
+		digester.add(data.data(), data.size());
+		LOG_GENERAL("Hash %1 vs %2", digester.get(), info.hash);
 		if (digester.get() != info.hash) {
-			LOG_GENERAL ("Existing frame %1 failed hash check", frame);
+			LOG_GENERAL("Existing frame %1 failed hash check", frame);
 			ok = false;
 		}
 	}
diff --git a/src/lib/reel_writer.h b/src/lib/reel_writer.h
index 02ee5f972..367b62349 100644
--- a/src/lib/reel_writer.h
+++ b/src/lib/reel_writer.h
@@ -64,7 +64,7 @@ namespace dcp {
 class ReelWriter : public WeakConstFilm
 {
 public:
-	ReelWriter (
+	ReelWriter(
 		std::weak_ptr<const Film> film,
 		dcpomatic::DCPTimePeriod period,
 		std::shared_ptr<Job> job,
@@ -74,16 +74,16 @@ public:
 		boost::filesystem::path output_dir
 		);
 
-	void write (std::shared_ptr<const dcp::Data> encoded, Frame frame, Eyes eyes);
+	void write(std::shared_ptr<const dcp::Data> encoded, Frame frame, Eyes eyes);
 	void fake_write(Frame frame, Eyes eyes);
-	void repeat_write (Frame frame, Eyes eyes);
-	void write (std::shared_ptr<const AudioBuffers> audio);
+	void repeat_write(Frame frame, Eyes eyes);
+	void write(std::shared_ptr<const AudioBuffers> audio);
 	void write(PlayerText text, TextType type, boost::optional<DCPTextTrack> track, dcpomatic::DCPTimePeriod period, FontIdMap const& fonts, std::shared_ptr<dcpomatic::Font> chosen_interop_font);
-	void write (std::shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata);
+	void write(std::shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata);
 	void write(std::shared_ptr<dcp::MonoMPEG2PictureFrame> image);
 
-	void finish (boost::filesystem::path output_dcp);
-	std::shared_ptr<dcp::Reel> create_reel (
+	void finish(boost::filesystem::path output_dcp);
+	std::shared_ptr<dcp::Reel> create_reel(
 		std::list<ReferencedReelAsset> const & refs,
 		boost::filesystem::path output_dcp,
 		bool ensure_subtitles,
@@ -91,13 +91,13 @@ public:
 		);
 	void calculate_digests(std::function<void (int64_t, int64_t)> set_progress);
 
-	Frame start () const;
+	Frame start() const;
 
-	dcpomatic::DCPTimePeriod period () const {
+	dcpomatic::DCPTimePeriod period() const {
 		return _period;
 	}
 
-	int first_nonexistent_frame () const {
+	int first_nonexistent_frame() const {
 		return _first_nonexistent_frame;
 	}
 
@@ -105,13 +105,13 @@ private:
 
 	friend struct ::write_frame_info_test;
 
-	Frame check_existing_picture_asset (boost::filesystem::path asset);
+	Frame check_existing_picture_asset(boost::filesystem::path asset);
 	bool existing_picture_frame_ok(dcp::File& asset_file, Frame frame);
-	std::shared_ptr<dcp::TextAsset> empty_text_asset (TextType type, boost::optional<DCPTextTrack> track, bool with_dummy) const;
+	std::shared_ptr<dcp::TextAsset> empty_text_asset(TextType type, boost::optional<DCPTextTrack> track, bool with_dummy) const;
 
-	std::shared_ptr<dcp::ReelPictureAsset> create_reel_picture (std::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
-	void create_reel_sound (std::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
-	void create_reel_text (
+	std::shared_ptr<dcp::ReelPictureAsset> create_reel_picture(std::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
+	void create_reel_sound(std::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
+	void create_reel_text(
 		std::shared_ptr<dcp::Reel> reel,
 		std::list<ReferencedReelAsset> const & refs,
 		int64_t duration,
@@ -119,7 +119,7 @@ private:
 		bool ensure_subtitles,
 		std::set<DCPTextTrack> ensure_closed_captions
 		) const;
-	void create_reel_markers (std::shared_ptr<dcp::Reel> reel) const;
+	void create_reel_markers(std::shared_ptr<dcp::Reel> reel) const;
 	float convert_vertical_position(StringText const& subtitle, dcp::SubtitleStandard to) const;
 
 	boost::filesystem::path _output_dir;
diff --git a/src/lib/upload_job.cc b/src/lib/upload_job.cc
index 113e3a7e8..3019b7662 100644
--- a/src/lib/upload_job.cc
+++ b/src/lib/upload_job.cc
@@ -46,62 +46,62 @@ using namespace boost::placeholders;
 #endif
 
 
-UploadJob::UploadJob (shared_ptr<const Film> film)
-	: Job (film)
-	, _status (_("Waiting"))
+UploadJob::UploadJob(shared_ptr<const Film> film)
+	: Job(film)
+	, _status(_("Waiting"))
 {
 
 }
 
 
-UploadJob::~UploadJob ()
+UploadJob::~UploadJob()
 {
-	stop_thread ();
+	stop_thread();
 }
 
 
 string
-UploadJob::name () const
+UploadJob::name() const
 {
 	return _("Copy DCP to TMS");
 }
 
 
 string
-UploadJob::json_name () const
+UploadJob::json_name() const
 {
 	return N_("upload");
 }
 
 
 void
-UploadJob::run ()
+UploadJob::run()
 {
-	LOG_GENERAL_NC (N_("Upload job starting"));
+	LOG_GENERAL_NC(N_("Upload job starting"));
 
 	scoped_ptr<Uploader> uploader;
 	switch (Config::instance()->tms_protocol()) {
 	case FileTransferProtocol::SCP:
-		uploader.reset (new SCPUploader(bind (&UploadJob::set_status, this, _1), bind(&UploadJob::set_progress, this, _1, false)));
+		uploader.reset(new SCPUploader(bind(&UploadJob::set_status, this, _1), bind(&UploadJob::set_progress, this, _1, false)));
 		break;
 	case FileTransferProtocol::FTP:
-		uploader.reset (new CurlUploader(bind (&UploadJob::set_status, this, _1), bind(&UploadJob::set_progress, this, _1, false)));
+		uploader.reset(new CurlUploader(bind(&UploadJob::set_status, this, _1), bind(&UploadJob::set_progress, this, _1, false)));
 		break;
 	}
 
-	uploader->upload (_film->dir(_film->dcp_name()));
+	uploader->upload(_film->dir(_film->dcp_name()));
 
-	set_progress (1);
-	set_status (N_(""));
-	set_state (FINISHED_OK);
+	set_progress(1);
+	set_status(N_(""));
+	set_state(FINISHED_OK);
 }
 
 
 string
-UploadJob::status () const
+UploadJob::status() const
 {
-	boost::mutex::scoped_lock lm (_status_mutex);
-	auto s = Job::status ();
+	boost::mutex::scoped_lock lm(_status_mutex);
+	auto s = Job::status();
 	if (!_status.empty() && !finished_in_error()) {
 		s += N_("; ") + _status;
 	}
@@ -110,8 +110,8 @@ UploadJob::status () const
 
 
 void
-UploadJob::set_status (string s)
+UploadJob::set_status(string s)
 {
-	boost::mutex::scoped_lock lm (_status_mutex);
+	boost::mutex::scoped_lock lm(_status_mutex);
 	_status = s;
 }
diff --git a/src/lib/upload_job.h b/src/lib/upload_job.h
index a3da164bf..87beec1ad 100644
--- a/src/lib/upload_job.h
+++ b/src/lib/upload_job.h
@@ -30,16 +30,16 @@
 class UploadJob : public Job
 {
 public:
-	explicit UploadJob (std::shared_ptr<const Film>);
-	~UploadJob ();
+	explicit UploadJob(std::shared_ptr<const Film>);
+	~UploadJob();
 
-	std::string name () const override;
-	std::string json_name () const override;
-	void run () override;
-	std::string status () const override;
+	std::string name() const override;
+	std::string json_name() const override;
+	void run() override;
+	std::string status() const override;
 
 private:
-	void set_status (std::string);
+	void set_status(std::string);
 
 	mutable boost::mutex _status_mutex;
 	std::string _status;
diff --git a/src/lib/upmixer_a.cc b/src/lib/upmixer_a.cc
index f402b6691..d87546a76 100644
--- a/src/lib/upmixer_a.cc
+++ b/src/lib/upmixer_a.cc
@@ -33,106 +33,106 @@ using std::string;
 using std::vector;
 
 
-UpmixerA::UpmixerA (int sampling_rate)
-	: _left (0.02, 1900.0 / sampling_rate, 4800.0 / sampling_rate)
-	, _right (0.02, 1900.0 / sampling_rate, 4800.0 / sampling_rate)
-	, _centre (0.01, 150.0 / sampling_rate, 1900.0 / sampling_rate)
-	, _lfe (0.01, 150.0 / sampling_rate)
-	, _ls (0.02, 4800.0 / sampling_rate, 20000.0 / sampling_rate)
-	, _rs (0.02, 4800.0 / sampling_rate, 20000.0 / sampling_rate)
+UpmixerA::UpmixerA(int sampling_rate)
+	: _left(0.02, 1900.0 / sampling_rate, 4800.0 / sampling_rate)
+	, _right(0.02, 1900.0 / sampling_rate, 4800.0 / sampling_rate)
+	, _centre(0.01, 150.0 / sampling_rate, 1900.0 / sampling_rate)
+	, _lfe(0.01, 150.0 / sampling_rate)
+	, _ls(0.02, 4800.0 / sampling_rate, 20000.0 / sampling_rate)
+	, _rs(0.02, 4800.0 / sampling_rate, 20000.0 / sampling_rate)
 {
 
 }
 
 
 string
-UpmixerA::name () const
+UpmixerA::name() const
 {
 	return _("Stereo to 5.1 up-mixer A");
 }
 
 
 string
-UpmixerA::id () const
+UpmixerA::id() const
 {
 	return N_("stereo-5.1-upmix-a");
 }
 
 
 int
-UpmixerA::out_channels () const
+UpmixerA::out_channels() const
 {
 	return 6;
 }
 
 
 shared_ptr<AudioProcessor>
-UpmixerA::clone (int sampling_rate) const
+UpmixerA::clone(int sampling_rate) const
 {
 	return make_shared<UpmixerA>(sampling_rate);
 }
 
 
 shared_ptr<AudioBuffers>
-UpmixerA::run (shared_ptr<const AudioBuffers> in, int channels)
+UpmixerA::run(shared_ptr<const AudioBuffers> in, int channels)
 {
 	/* Input L and R */
-	auto in_L = in->channel (0);
-	auto in_R = in->channel (1);
+	auto in_L = in->channel(0);
+	auto in_R = in->channel(1);
 
 	/* Mix of L and R; -6dB down in amplitude (3dB in terms of power) */
-	auto in_LR = in_L->clone ();
-	in_LR->accumulate_frames (in_R.get(), in_R->frames(), 0, 0);
-	in_LR->apply_gain (-6);
+	auto in_LR = in_L->clone();
+	in_LR->accumulate_frames(in_R.get(), in_R->frames(), 0, 0);
+	in_LR->apply_gain(-6);
 
 	/* Run filters */
 	vector<shared_ptr<AudioBuffers>> all_out;
-	all_out.push_back (_left.run(in_L));
-	all_out.push_back (_right.run(in_R));
-	all_out.push_back (_centre.run(in_LR));
-	all_out.push_back (_lfe.run(in_LR));
-	all_out.push_back (_ls.run(in_L));
-	all_out.push_back (_rs.run(in_R));
+	all_out.push_back(_left.run(in_L));
+	all_out.push_back(_right.run(in_R));
+	all_out.push_back(_centre.run(in_LR));
+	all_out.push_back(_lfe.run(in_LR));
+	all_out.push_back(_ls.run(in_L));
+	all_out.push_back(_rs.run(in_R));
 
 	auto out = make_shared<AudioBuffers>(channels, in->frames());
-	int const N = min (channels, 6);
+	int const N = min(channels, 6);
 
 	for (int i = 0; i < N; ++i) {
-		out->copy_channel_from (all_out[i].get(), 0, i);
+		out->copy_channel_from(all_out[i].get(), 0, i);
 	}
 
 	for (int i = N; i < channels; ++i) {
-		out->make_silent (i);
+		out->make_silent(i);
 	}
 
 	return out;
 }
 
 void
-UpmixerA::flush ()
+UpmixerA::flush()
 {
-	_left.flush ();
-	_right.flush ();
-	_centre.flush ();
-	_lfe.flush ();
-	_ls.flush ();
-	_rs.flush ();
+	_left.flush();
+	_right.flush();
+	_centre.flush();
+	_lfe.flush();
+	_ls.flush();
+	_rs.flush();
 }
 
 
 void
-UpmixerA::make_audio_mapping_default (AudioMapping& mapping) const
+UpmixerA::make_audio_mapping_default(AudioMapping& mapping) const
 {
 	/* Just map the first two input channels to our L/R */
-	mapping.make_zero ();
-	for (int i = 0; i < min (2, mapping.input_channels()); ++i) {
-		mapping.set (i, i, 1);
+	mapping.make_zero();
+	for (int i = 0; i < min(2, mapping.input_channels()); ++i) {
+		mapping.set(i, i, 1);
 	}
 }
 
 
 vector<NamedChannel>
-UpmixerA::input_names () const
+UpmixerA::input_names() const
 {
 	return {
 		NamedChannel(_("Upmix L"), 0),
diff --git a/src/lib/upmixer_a.h b/src/lib/upmixer_a.h
index 9e364dcc9..9b1e09ee5 100644
--- a/src/lib/upmixer_a.h
+++ b/src/lib/upmixer_a.h
@@ -34,16 +34,16 @@
 class UpmixerA : public AudioProcessor
 {
 public:
-	explicit UpmixerA (int sampling_rate);
-
-	std::string name () const override;
-	std::string id () const override;
-	int out_channels () const override;
-	std::shared_ptr<AudioProcessor> clone (int) const override;
-	std::shared_ptr<AudioBuffers> run (std::shared_ptr<const AudioBuffers>, int channels) override;
-	void flush () override;
-	void make_audio_mapping_default (AudioMapping& mapping) const override;
-	std::vector<NamedChannel> input_names () const override;
+	explicit UpmixerA(int sampling_rate);
+
+	std::string name() const override;
+	std::string id() const override;
+	int out_channels() const override;
+	std::shared_ptr<AudioProcessor> clone(int) const override;
+	std::shared_ptr<AudioBuffers> run(std::shared_ptr<const AudioBuffers>, int channels) override;
+	void flush() override;
+	void make_audio_mapping_default(AudioMapping& mapping) const override;
+	std::vector<NamedChannel> input_names() const override;
 
 private:
 	BandPassAudioFilter _left;
diff --git a/src/lib/upmixer_b.cc b/src/lib/upmixer_b.cc
index 3b0c2d94f..40bed6b6e 100644
--- a/src/lib/upmixer_b.cc
+++ b/src/lib/upmixer_b.cc
@@ -33,89 +33,89 @@ using std::vector;
 using std::shared_ptr;
 
 
-UpmixerB::UpmixerB (int sampling_rate)
-	: _lfe (0.01, 150.0 / sampling_rate)
-	, _delay (0.02 * sampling_rate)
+UpmixerB::UpmixerB(int sampling_rate)
+	: _lfe(0.01, 150.0 / sampling_rate)
+	, _delay(0.02 * sampling_rate)
 {
 
 }
 
 
 string
-UpmixerB::name () const
+UpmixerB::name() const
 {
 	return _("Stereo to 5.1 up-mixer B");
 }
 
 
 string
-UpmixerB::id () const
+UpmixerB::id() const
 {
 	return N_("stereo-5.1-upmix-b");
 }
 
 
 int
-UpmixerB::out_channels () const
+UpmixerB::out_channels() const
 {
 	return 6;
 }
 
 
 shared_ptr<AudioProcessor>
-UpmixerB::clone (int sampling_rate) const
+UpmixerB::clone(int sampling_rate) const
 {
 	return make_shared<UpmixerB>(sampling_rate);
 }
 
 
 shared_ptr<AudioBuffers>
-UpmixerB::run (shared_ptr<const AudioBuffers> in, int channels)
+UpmixerB::run(shared_ptr<const AudioBuffers> in, int channels)
 {
 	auto out = make_shared<AudioBuffers>(channels, in->frames());
 
 	/* L + R minus 6dB (in terms of amplitude) */
 	auto in_LR = in->channel(0);
-	in_LR->accumulate_frames (in->channel(1).get(), in->frames(), 0, 0);
-	in_LR->apply_gain (-6);
+	in_LR->accumulate_frames(in->channel(1).get(), in->frames(), 0, 0);
+	in_LR->apply_gain(-6);
 
 	if (channels > 0) {
 		/* L = Lt */
-		out->copy_channel_from (in.get(), 0, 0);
+		out->copy_channel_from(in.get(), 0, 0);
 	}
 
 	if (channels > 1) {
 		/* R = Rt */
-		out->copy_channel_from (in.get(), 1, 1);
+		out->copy_channel_from(in.get(), 1, 1);
 	}
 
 	if (channels > 2) {
 		/* C = L + R minus 3dB */
-		out->copy_channel_from (in_LR.get(), 0, 2);
+		out->copy_channel_from(in_LR.get(), 0, 2);
 	}
 
 	if (channels > 3) {
 		/* Lfe is filtered C */
-		out->copy_channel_from (_lfe.run(in_LR).get(), 0, 3);
+		out->copy_channel_from(_lfe.run(in_LR).get(), 0, 3);
 	}
 
 	shared_ptr<AudioBuffers> S;
 	if (channels > 4) {
 		/* Ls is L - R with some delay */
 		auto sub = make_shared<AudioBuffers>(1, in->frames());
-		sub->copy_channel_from (in.get(), 0, 0);
-		float* p = sub->data (0);
-		float const * q = in->data (1);
+		sub->copy_channel_from(in.get(), 0, 0);
+		float* p = sub->data(0);
+		float const * q = in->data(1);
 		for (int i = 0; i < in->frames(); ++i) {
 			*p++ -= *q++;
 		}
-		S = _delay.run (sub);
-		out->copy_channel_from (S.get(), 0, 4);
+		S = _delay.run(sub);
+		out->copy_channel_from(S.get(), 0, 4);
 	}
 
 	if (channels > 5) {
 		/* Rs = Ls */
-		out->copy_channel_from (S.get(), 0, 5);
+		out->copy_channel_from(S.get(), 0, 5);
 	}
 
 	return out;
@@ -123,26 +123,26 @@ UpmixerB::run (shared_ptr<const AudioBuffers> in, int channels)
 
 
 void
-UpmixerB::flush ()
+UpmixerB::flush()
 {
-	_lfe.flush ();
-	_delay.flush ();
+	_lfe.flush();
+	_delay.flush();
 }
 
 
 void
-UpmixerB::make_audio_mapping_default (AudioMapping& mapping) const
+UpmixerB::make_audio_mapping_default(AudioMapping& mapping) const
 {
 	/* Just map the first two input channels to our L/R */
-	mapping.make_zero ();
-	for (int i = 0; i < min (2, mapping.input_channels()); ++i) {
-		mapping.set (i, i, 1);
+	mapping.make_zero();
+	for (int i = 0; i < min(2, mapping.input_channels()); ++i) {
+		mapping.set(i, i, 1);
 	}
 }
 
 
 vector<NamedChannel>
-UpmixerB::input_names () const
+UpmixerB::input_names() const
 {
 	return {
 		NamedChannel(_("Upmix L"), 0),
diff --git a/src/lib/upmixer_b.h b/src/lib/upmixer_b.h
index 611ed6a90..6ac310bdb 100644
--- a/src/lib/upmixer_b.h
+++ b/src/lib/upmixer_b.h
@@ -32,16 +32,16 @@
 class UpmixerB : public AudioProcessor
 {
 public:
-	explicit UpmixerB (int sampling_rate);
-
-	std::string name () const override;
-	std::string id () const override;
-	int out_channels () const override;
-	std::shared_ptr<AudioProcessor> clone (int) const override;
-	std::shared_ptr<AudioBuffers> run (std::shared_ptr<const AudioBuffers>, int channels) override;
-	void flush () override;
-	void make_audio_mapping_default (AudioMapping& mapping) const override;
-	std::vector<NamedChannel> input_names () const override;
+	explicit UpmixerB(int sampling_rate);
+
+	std::string name() const override;
+	std::string id() const override;
+	int out_channels() const override;
+	std::shared_ptr<AudioProcessor> clone(int) const override;
+	std::shared_ptr<AudioBuffers> run(std::shared_ptr<const AudioBuffers>, int channels) override;
+	void flush() override;
+	void make_audio_mapping_default(AudioMapping& mapping) const override;
+	std::vector<NamedChannel> input_names() const override;
 
 private:
 	LowPassAudioFilter _lfe;