White space: ffmpeg_file_encoder.{cc,h}

2 files changed, 122 insertions, 122 deletions

diff --git a/src/lib/ffmpeg_file_encoder.cc b/src/lib/ffmpeg_file_encoder.cc
index 9df078ad4..e63d92d5b 100644
--- a/src/lib/ffmpeg_file_encoder.cc
+++ b/src/lib/ffmpeg_file_encoder.cc
@@ -54,18 +54,18 @@ int FFmpegFileEncoder::_audio_stream_index_base = 1;
 class ExportAudioStream
 {
 public:
-	ExportAudioStream (string codec_name, int channels, int frame_rate, AVSampleFormat sample_format, AVFormatContext* format_context, int stream_index)
-		: _format_context (format_context)
-		, _stream_index (stream_index)
+	ExportAudioStream(string codec_name, int channels, int frame_rate, AVSampleFormat sample_format, AVFormatContext* format_context, int stream_index)
+		: _format_context(format_context)
+		, _stream_index(stream_index)
 	{
-		_codec = avcodec_find_encoder_by_name (codec_name.c_str());
+		_codec = avcodec_find_encoder_by_name(codec_name.c_str());
 		if (!_codec) {
-			throw EncodeError (fmt::format("avcodec_find_encoder_by_name failed for {}", codec_name));
+			throw EncodeError(fmt::format("avcodec_find_encoder_by_name failed for {}", codec_name));
 		}
 
-		_codec_context = avcodec_alloc_context3 (_codec);
+		_codec_context = avcodec_alloc_context3(_codec);
 		if (!_codec_context) {
-			throw std::bad_alloc ();
+			throw std::bad_alloc();
 		}
 
 		/* XXX: configurable */
@@ -74,81 +74,81 @@ public:
 		_codec_context->sample_rate = frame_rate;
 		av_channel_layout_default(&_codec_context->ch_layout, channels);
 
-		int r = avcodec_open2 (_codec_context, _codec, 0);
+		int r = avcodec_open2(_codec_context, _codec, 0);
 		if (r < 0) {
-			throw EncodeError (N_("avcodec_open2"), N_("ExportAudioStream::ExportAudioStream"), r);
+			throw EncodeError(N_("avcodec_open2"), N_("ExportAudioStream::ExportAudioStream"), r);
 		}
 
-		_stream = avformat_new_stream (format_context, _codec);
+		_stream = avformat_new_stream(format_context, _codec);
 		if (!_stream) {
-			throw EncodeError (N_("avformat_new_stream"), N_("ExportAudioStream::ExportAudioStream"));
+			throw EncodeError(N_("avformat_new_stream"), N_("ExportAudioStream::ExportAudioStream"));
 		}
 
 		_stream->id = stream_index;
 		_stream->disposition |= AV_DISPOSITION_DEFAULT;
-		r = avcodec_parameters_from_context (_stream->codecpar, _codec_context);
+		r = avcodec_parameters_from_context(_stream->codecpar, _codec_context);
 		if (r < 0) {
-			throw EncodeError (N_("avcodec_parameters_from_context"), N_("ExportAudioStream::ExportAudioStream"), r);
+			throw EncodeError(N_("avcodec_parameters_from_context"), N_("ExportAudioStream::ExportAudioStream"), r);
 		}
 	}
 
-	~ExportAudioStream ()
+	~ExportAudioStream()
 	{
 		avcodec_free_context(&_codec_context);
 	}
 
-	ExportAudioStream (ExportAudioStream const&) = delete;
-	ExportAudioStream& operator= (ExportAudioStream const&) = delete;
+	ExportAudioStream(ExportAudioStream const&) = delete;
+	ExportAudioStream& operator=(ExportAudioStream const&) = delete;
 
-	int frame_size () const {
+	int frame_size() const {
 		return _codec_context->frame_size;
 	}
 
-	bool flush ()
+	bool flush()
 	{
-		int r = avcodec_send_frame (_codec_context, nullptr);
+		int r = avcodec_send_frame(_codec_context, nullptr);
 		if (r < 0 && r != AVERROR_EOF) {
 			/* We get EOF if we've already flushed the stream once */
-			throw EncodeError (N_("avcodec_send_frame"), N_("ExportAudioStream::flush"), r);
+			throw EncodeError(N_("avcodec_send_frame"), N_("ExportAudioStream::flush"), r);
 		}
 
 		ffmpeg::Packet packet;
-		r = avcodec_receive_packet (_codec_context, packet.get());
+		r = avcodec_receive_packet(_codec_context, packet.get());
 		if (r == AVERROR_EOF) {
 			return true;
 		} else if (r < 0) {
-			throw EncodeError (N_("avcodec_receive_packet"), N_("ExportAudioStream::flush"), r);
+			throw EncodeError(N_("avcodec_receive_packet"), N_("ExportAudioStream::flush"), r);
 		}
 
 		packet->stream_index = _stream_index;
-		av_interleaved_write_frame (_format_context, packet.get());
+		av_interleaved_write_frame(_format_context, packet.get());
 		return false;
 	}
 
-	void write (int size, int channel_offset, int channels, float* const* data, int64_t sample_offset)
+	void write(int size, int channel_offset, int channels, float* const* data, int64_t sample_offset)
 	{
-		DCPOMATIC_ASSERT (size);
+		DCPOMATIC_ASSERT(size);
 
-		auto frame = av_frame_alloc ();
-		DCPOMATIC_ASSERT (frame);
+		auto frame = av_frame_alloc();
+		DCPOMATIC_ASSERT(frame);
 
 		int line_size;
-		int const buffer_size = av_samples_get_buffer_size (&line_size, channels, size, _codec_context->sample_fmt, 0);
-		DCPOMATIC_ASSERT (buffer_size >= 0);
+		int const buffer_size = av_samples_get_buffer_size(&line_size, channels, size, _codec_context->sample_fmt, 0);
+		DCPOMATIC_ASSERT(buffer_size >= 0);
 
-		auto samples = av_malloc (buffer_size);
-		DCPOMATIC_ASSERT (samples);
+		auto samples = av_malloc(buffer_size);
+		DCPOMATIC_ASSERT(samples);
 
 		frame->nb_samples = size;
 		frame->format = _codec_context->sample_fmt;
 		frame->ch_layout.nb_channels = channels;
-		int r = avcodec_fill_audio_frame (frame, channels, _codec_context->sample_fmt, (const uint8_t *) samples, buffer_size, 0);
-		DCPOMATIC_ASSERT (r >= 0);
+		int r = avcodec_fill_audio_frame(frame, channels, _codec_context->sample_fmt, (const uint8_t *) samples, buffer_size, 0);
+		DCPOMATIC_ASSERT(r >= 0);
 
 		switch (_codec_context->sample_fmt) {
 		case AV_SAMPLE_FMT_S16:
 		{
-			int16_t* q = reinterpret_cast<int16_t*> (samples);
+			int16_t* q = reinterpret_cast<int16_t*>(samples);
 			for (int i = 0; i < size; ++i) {
 				for (int j = 0; j < channels; ++j) {
 					*q++ = data[j + channel_offset][i] * 32767;
@@ -158,7 +158,7 @@ public:
 		}
 		case AV_SAMPLE_FMT_S32:
 		{
-			int32_t* q = reinterpret_cast<int32_t*> (samples);
+			int32_t* q = reinterpret_cast<int32_t*>(samples);
 			for (int i = 0; i < size; ++i) {
 				for (int j = 0; j < channels; ++j) {
 					*q++ = data[j + channel_offset][i] * 2147483647;
@@ -169,31 +169,31 @@ public:
 		case AV_SAMPLE_FMT_FLTP:
 		{
 			for (int i = 0; i < channels; ++i) {
-				memcpy (reinterpret_cast<float*>(static_cast<uint8_t*>(samples) + i * line_size), data[i + channel_offset], sizeof(float) * size);
+				memcpy(reinterpret_cast<float*>(static_cast<uint8_t*>(samples) + i * line_size), data[i + channel_offset], sizeof(float) * size);
 			}
 			break;
 		}
 		default:
-			DCPOMATIC_ASSERT (false);
+			DCPOMATIC_ASSERT(false);
 		}
 
-		DCPOMATIC_ASSERT (_codec_context->time_base.num == 1);
+		DCPOMATIC_ASSERT(_codec_context->time_base.num == 1);
 		frame->pts = sample_offset * _codec_context->time_base.den / _codec_context->sample_rate;
 
-		r = avcodec_send_frame (_codec_context, frame);
-		av_free (samples);
-		av_frame_free (&frame);
+		r = avcodec_send_frame(_codec_context, frame);
+		av_free(samples);
+		av_frame_free(&frame);
 		if (r < 0) {
-			throw EncodeError (N_("avcodec_send_frame"), N_("ExportAudioStream::write"), r);
+			throw EncodeError(N_("avcodec_send_frame"), N_("ExportAudioStream::write"), r);
 		}
 
 		ffmpeg::Packet packet;
-		r = avcodec_receive_packet (_codec_context, packet.get());
+		r = avcodec_receive_packet(_codec_context, packet.get());
 		if (r < 0 && r != AVERROR(EAGAIN)) {
-			throw EncodeError (N_("avcodec_receive_packet"), N_("ExportAudioStream::write"), r);
+			throw EncodeError(N_("avcodec_receive_packet"), N_("ExportAudioStream::write"), r);
 		} else if (r >= 0) {
 			packet->stream_index = _stream_index;
-			av_interleaved_write_frame (_format_context, packet.get());
+			av_interleaved_write_frame(_format_context, packet.get());
 		}
 	}
 
@@ -206,7 +206,7 @@ private:
 };
 
 
-FFmpegFileEncoder::FFmpegFileEncoder (
+FFmpegFileEncoder::FFmpegFileEncoder(
 	dcp::Size video_frame_size,
 	int video_frame_rate,
 	int audio_frame_rate,
@@ -216,14 +216,14 @@ FFmpegFileEncoder::FFmpegFileEncoder (
 	int x264_crf,
 	boost::filesystem::path output
 	)
-	: _audio_stream_per_channel (audio_stream_per_channel)
-	, _audio_channels (channels)
-	, _output (output)
-	, _video_frame_size (video_frame_size)
-	, _video_frame_rate (video_frame_rate)
-	, _audio_frame_rate (audio_frame_rate)
+	: _audio_stream_per_channel(audio_stream_per_channel)
+	, _audio_channels(channels)
+	, _output(output)
+	, _video_frame_size(video_frame_size)
+	, _video_frame_rate(video_frame_rate)
+	, _audio_frame_rate(audio_frame_rate)
 {
-	_pixel_format = pixel_format (format);
+	_pixel_format = pixel_format(format);
 
 	switch (format) {
 	case ExportFormat::PRORES_4444:
@@ -237,8 +237,8 @@ FFmpegFileEncoder::FFmpegFileEncoder (
 		_sample_format = AV_SAMPLE_FMT_S32;
 		_video_codec_name = "prores_ks";
 		_audio_codec_name = "pcm_s24le";
-		av_dict_set (&_video_options, "profile", "3", 0);
-		av_dict_set (&_video_options, "threads", "auto", 0);
+		av_dict_set(&_video_options, "profile", "3", 0);
+		av_dict_set(&_video_options, "threads", "auto", 0);
 		break;
 	case ExportFormat::PRORES_LT:
 		_sample_format = AV_SAMPLE_FMT_S32;
@@ -251,48 +251,48 @@ FFmpegFileEncoder::FFmpegFileEncoder (
 		_sample_format = AV_SAMPLE_FMT_FLTP;
 		_video_codec_name = "libx264";
 		_audio_codec_name = "aac";
-		av_dict_set_int (&_video_options, "crf", x264_crf, 0);
+		av_dict_set_int(&_video_options, "crf", x264_crf, 0);
 		break;
 	default:
-		DCPOMATIC_ASSERT (false);
+		DCPOMATIC_ASSERT(false);
 	}
 
-	int r = avformat_alloc_output_context2 (&_format_context, 0, 0, _output.string().c_str());
+	int r = avformat_alloc_output_context2(&_format_context, 0, 0, _output.string().c_str());
 	if (!_format_context) {
-		throw EncodeError (N_("avformat_alloc_output_context2"), "FFmpegFileEncoder::FFmpegFileEncoder", r);
+		throw EncodeError(N_("avformat_alloc_output_context2"), "FFmpegFileEncoder::FFmpegFileEncoder", r);
 	}
 
-	setup_video ();
-	setup_audio ();
+	setup_video();
+	setup_audio();
 
-	r = avio_open_boost (&_format_context->pb, _output, AVIO_FLAG_WRITE);
+	r = avio_open_boost(&_format_context->pb, _output, AVIO_FLAG_WRITE);
 	if (r < 0) {
-		throw EncodeError (fmt::format(_("Could not open output file {} ({})"), _output.string(), r));
+		throw EncodeError(fmt::format(_("Could not open output file {} ({})"), _output.string(), r));
 	}
 
 	AVDictionary* options = nullptr;
 
-	r = avformat_write_header (_format_context, &options);
+	r = avformat_write_header(_format_context, &options);
 	if (r < 0) {
-		throw EncodeError (N_("avformat_write_header"), N_("FFmpegFileEncoder::FFmpegFileEncoder"), r);
+		throw EncodeError(N_("avformat_write_header"), N_("FFmpegFileEncoder::FFmpegFileEncoder"), r);
 	}
 
 	_pending_audio = make_shared<AudioBuffers>(channels, 0);
 }
 
 
-FFmpegFileEncoder::~FFmpegFileEncoder ()
+FFmpegFileEncoder::~FFmpegFileEncoder()
 {
-	_audio_streams.clear ();
+	_audio_streams.clear();
 	avcodec_free_context(&_video_codec_context);
-	avio_close (_format_context->pb);
+	avio_close(_format_context->pb);
 	_format_context->pb = nullptr;
-	avformat_free_context (_format_context);
+	avformat_free_context(_format_context);
 }
 
 
 AVPixelFormat
-FFmpegFileEncoder::pixel_format (ExportFormat format)
+FFmpegFileEncoder::pixel_format(ExportFormat format)
 {
 	switch (format) {
 	case ExportFormat::PRORES_4444:
@@ -303,7 +303,7 @@ FFmpegFileEncoder::pixel_format (ExportFormat format)
 	case ExportFormat::H264_AAC:
 		return AV_PIX_FMT_YUV420P;
 	default:
-		DCPOMATIC_ASSERT (false);
+		DCPOMATIC_ASSERT(false);
 	}
 
 	return AV_PIX_FMT_YUV422P10;
@@ -311,16 +311,16 @@ FFmpegFileEncoder::pixel_format (ExportFormat format)
 
 
 void
-FFmpegFileEncoder::setup_video ()
+FFmpegFileEncoder::setup_video()
 {
-	_video_codec = avcodec_find_encoder_by_name (_video_codec_name.c_str());
+	_video_codec = avcodec_find_encoder_by_name(_video_codec_name.c_str());
 	if (!_video_codec) {
-		throw EncodeError (fmt::format("avcodec_find_encoder_by_name failed for {}", _video_codec_name));
+		throw EncodeError(fmt::format("avcodec_find_encoder_by_name failed for {}", _video_codec_name));
 	}
 
-	_video_codec_context = avcodec_alloc_context3 (_video_codec);
+	_video_codec_context = avcodec_alloc_context3(_video_codec);
 	if (!_video_codec_context) {
-		throw std::bad_alloc ();
+		throw std::bad_alloc();
 	}
 
 	/* Variable quantisation */
@@ -331,25 +331,25 @@ FFmpegFileEncoder::setup_video ()
 	_video_codec_context->pix_fmt = _pixel_format;
 	_video_codec_context->flags |= AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_GLOBAL_HEADER;
 
-	if (avcodec_open2 (_video_codec_context, _video_codec, &_video_options) < 0) {
+	if (avcodec_open2(_video_codec_context, _video_codec, &_video_options) < 0) {
 		throw EncodeError(N_("avcodec_open2"), N_("FFmpegFileEncoder::setup_video"));
 	}
 
-	_video_stream = avformat_new_stream (_format_context, _video_codec);
+	_video_stream = avformat_new_stream(_format_context, _video_codec);
 	if (!_video_stream) {
-		throw EncodeError (N_("avformat_new_stream"), N_("FFmpegFileEncoder::setup_video"));
+		throw EncodeError(N_("avformat_new_stream"), N_("FFmpegFileEncoder::setup_video"));
 	}
 
 	_video_stream->id = _video_stream_index;
-	int r = avcodec_parameters_from_context (_video_stream->codecpar, _video_codec_context);
+	int r = avcodec_parameters_from_context(_video_stream->codecpar, _video_codec_context);
 	if (r < 0) {
-		throw EncodeError (N_("avcodec_parameters_from_context"), N_("FFmpegFileEncoder::setup_video"), r);
+		throw EncodeError(N_("avcodec_parameters_from_context"), N_("FFmpegFileEncoder::setup_video"), r);
 	}
 }
 
 
 void
-FFmpegFileEncoder::setup_audio ()
+FFmpegFileEncoder::setup_audio()
 {
 	int const streams = _audio_stream_per_channel ? _audio_channels : 1;
 	int const channels_per_stream = _audio_stream_per_channel ? 1 : _audio_channels;
@@ -365,32 +365,32 @@ FFmpegFileEncoder::setup_audio ()
 
 
 void
-FFmpegFileEncoder::flush ()
+FFmpegFileEncoder::flush()
 {
 	if (_pending_audio->frames() > 0) {
-		audio_frame (_pending_audio->frames ());
+		audio_frame(_pending_audio->frames());
 	}
 
 	bool flushed_video = false;
 	bool flushed_audio = false;
 
 	while (!flushed_video || !flushed_audio) {
-		int r = avcodec_send_frame (_video_codec_context, nullptr);
+		int r = avcodec_send_frame(_video_codec_context, nullptr);
 		if (r < 0 && r != AVERROR_EOF) {
 			/* We get EOF if we've already flushed the stream once */
-			throw EncodeError (N_("avcodec_send_frame"), N_("FFmpegFileEncoder::flush"), r);
+			throw EncodeError(N_("avcodec_send_frame"), N_("FFmpegFileEncoder::flush"), r);
 		}
 
 		ffmpeg::Packet packet;
-		r = avcodec_receive_packet (_video_codec_context, packet.get());
+		r = avcodec_receive_packet(_video_codec_context, packet.get());
 		if (r == AVERROR_EOF) {
 			flushed_video = true;
 		} else if (r < 0) {
-			throw EncodeError (N_("avcodec_receive_packet"), N_("FFmpegFileEncoder::flush"), r);
+			throw EncodeError(N_("avcodec_receive_packet"), N_("FFmpegFileEncoder::flush"), r);
 		} else {
 			packet->stream_index = _video_stream_index;
 			packet->duration = _video_stream->time_base.den / _video_frame_rate;
-			av_interleaved_write_frame (_format_context, packet.get());
+			av_interleaved_write_frame(_format_context, packet.get());
 		}
 
 		flushed_audio = true;
@@ -413,53 +413,53 @@ FFmpegFileEncoder::flush ()
 
 
 void
-FFmpegFileEncoder::video (shared_ptr<PlayerVideo> video, DCPTime time)
+FFmpegFileEncoder::video(shared_ptr<PlayerVideo> video, DCPTime time)
 {
 	/* All our output formats are video range at the moment */
 	auto image = video->image(force(_pixel_format), VideoRange::VIDEO, false);
 
-	auto frame = av_frame_alloc ();
-	DCPOMATIC_ASSERT (frame);
+	auto frame = av_frame_alloc();
+	DCPOMATIC_ASSERT(frame);
 
 	for (int i = 0; i < 3; ++i) {
 		auto buffer = _pending_images.create_buffer(image, i);
-		frame->buf[i] = av_buffer_ref (buffer);
+		frame->buf[i] = av_buffer_ref(buffer);
 		frame->data[i] = buffer->data;
 		frame->linesize[i] = image->stride()[i];
-		av_buffer_unref (&buffer);
+		av_buffer_unref(&buffer);
 	}
 
 	frame->width = image->size().width;
 	frame->height = image->size().height;
 	frame->format = _pixel_format;
-	DCPOMATIC_ASSERT (_video_stream->time_base.num == 1);
+	DCPOMATIC_ASSERT(_video_stream->time_base.num == 1);
 	frame->pts = time.get() * _video_stream->time_base.den / DCPTime::HZ;
 
-	int r = avcodec_send_frame (_video_codec_context, frame);
-	av_frame_free (&frame);
+	int r = avcodec_send_frame(_video_codec_context, frame);
+	av_frame_free(&frame);
 	if (r < 0) {
-		throw EncodeError (N_("avcodec_send_frame"), N_("FFmpegFileEncoder::video"), r);
+		throw EncodeError(N_("avcodec_send_frame"), N_("FFmpegFileEncoder::video"), r);
 	}
 
 	ffmpeg::Packet packet;
-	r = avcodec_receive_packet (_video_codec_context, packet.get());
+	r = avcodec_receive_packet(_video_codec_context, packet.get());
 	if (r < 0 && r != AVERROR(EAGAIN)) {
-		throw EncodeError (N_("avcodec_receive_packet"), N_("FFmpegFileEncoder::video"), r);
+		throw EncodeError(N_("avcodec_receive_packet"), N_("FFmpegFileEncoder::video"), r);
 	} else if (r >= 0) {
 		packet->stream_index = _video_stream_index;
 		packet->duration = _video_stream->time_base.den / _video_frame_rate;
-		av_interleaved_write_frame (_format_context, packet.get());
+		av_interleaved_write_frame(_format_context, packet.get());
 	}
 }
 
 
 /** Called when the player gives us some audio */
 void
-FFmpegFileEncoder::audio (shared_ptr<AudioBuffers> audio)
+FFmpegFileEncoder::audio(shared_ptr<AudioBuffers> audio)
 {
-	_pending_audio->append (audio);
+	_pending_audio->append(audio);
 
-	DCPOMATIC_ASSERT (!_audio_streams.empty());
+	DCPOMATIC_ASSERT(!_audio_streams.empty());
 	int frame_size = _audio_streams[0]->frame_size();
 	if (frame_size == 0) {
 		/* codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE */
@@ -467,33 +467,33 @@ FFmpegFileEncoder::audio (shared_ptr<AudioBuffers> audio)
 	}
 
 	while (_pending_audio->frames() >= frame_size) {
-		audio_frame (frame_size);
+		audio_frame(frame_size);
 	}
 }
 
 
 void
-FFmpegFileEncoder::audio_frame (int size)
+FFmpegFileEncoder::audio_frame(int size)
 {
 	if (_audio_stream_per_channel) {
 		int offset = 0;
 		for (auto i: _audio_streams) {
-			i->write (size, offset, 1, _pending_audio->data(), _audio_frames);
+			i->write(size, offset, 1, _pending_audio->data(), _audio_frames);
 			++offset;
 		}
 	} else {
-		DCPOMATIC_ASSERT (!_audio_streams.empty());
-		DCPOMATIC_ASSERT (_pending_audio->channels());
-		_audio_streams[0]->write (size, 0, _pending_audio->channels(), _pending_audio->data(), _audio_frames);
+		DCPOMATIC_ASSERT(!_audio_streams.empty());
+		DCPOMATIC_ASSERT(_pending_audio->channels());
+		_audio_streams[0]->write(size, 0, _pending_audio->channels(), _pending_audio->data(), _audio_frames);
 	}
 
-	_pending_audio->trim_start (size);
+	_pending_audio->trim_start(size);
 	_audio_frames += size;
 }
 
 
 void
-FFmpegFileEncoder::subtitle (PlayerText, DCPTimePeriod)
+FFmpegFileEncoder::subtitle(PlayerText, DCPTimePeriod)
 {
 
 }
diff --git a/src/lib/ffmpeg_file_encoder.h b/src/lib/ffmpeg_file_encoder.h
index a365f463a..a975d4519 100644
--- a/src/lib/ffmpeg_file_encoder.h
+++ b/src/lib/ffmpeg_file_encoder.h
@@ -57,7 +57,7 @@ enum class ExportFormat
 class FFmpegFileEncoder
 {
 public:
-	FFmpegFileEncoder (
+	FFmpegFileEncoder(
 		dcp::Size video_frame_size,
 		int video_frame_rate,
 		int audio_frame_rate,
@@ -68,21 +68,21 @@ public:
 		boost::filesystem::path output
 		);
 
-	~FFmpegFileEncoder ();
+	~FFmpegFileEncoder();
 
-	void video (std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime);
-	void audio (std::shared_ptr<AudioBuffers>);
-	void subtitle (PlayerText, dcpomatic::DCPTimePeriod);
+	void video(std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime);
+	void audio(std::shared_ptr<AudioBuffers>);
+	void subtitle(PlayerText, dcpomatic::DCPTimePeriod);
 
-	void flush ();
+	void flush();
 
-	static AVPixelFormat pixel_format (ExportFormat format);
+	static AVPixelFormat pixel_format(ExportFormat format);
 
 private:
-	void setup_video ();
-	void setup_audio ();
+	void setup_video();
+	void setup_audio();
 
-	void audio_frame (int size);
+	void audio_frame(int size);
 
 	AVCodec const * _video_codec = nullptr;
 	AVCodecContext* _video_codec_context = nullptr;