NO-OP: clang-format

libs/ardour/ardour/ffmpegfileimportable.h

@@ -29,23 +29,25 @@
 
 namespace ARDOUR {
 
-class LIBARDOUR_API FFMPEGFileImportableSource : public ImportableSource {
+class LIBARDOUR_API FFMPEGFileImportableSource : public ImportableSource
+{
 public:
 	enum {
 		ALL_CHANNELS = -1,
 	};
-	FFMPEGFileImportableSource(const std::string &path, int channel = ALL_CHANNELS);
+
-	virtual ~FFMPEGFileImportableSource();
+	FFMPEGFileImportableSource (const std::string& path, int channel = ALL_CHANNELS);
+
+	virtual ~FFMPEGFileImportableSource ();
 
 	/* ImportableSource API */
+	samplecnt_t read (Sample*, samplecnt_t nframes);
 	uint32_t    channels () const { return _channels; }
 	samplecnt_t length () const { return _length; }
 	samplecnt_t samplerate () const { return _samplerate; }
-	samplepos_t natural_position () const { return _natural_position; }
 	void        seek (samplepos_t pos);
-	samplecnt_t read (Sample*, samplecnt_t nframes);
+	samplepos_t natural_position () const { return _natural_position; }
-
+	bool        clamped_at_unity () const { return false; }
-	bool clamped_at_unity () const { return false; }
 
 	std::string format_name () const { return _format_name; }
 
@@ -56,29 +58,30 @@ private:
 	void did_read_data (std::string data, size_t size);
 
 	std::string _path;
-	int _channel;
+	int         _channel;
 
-	uint32_t _channels;
+	uint32_t    _channels;
 	samplecnt_t _length;
 	samplecnt_t _samplerate;
 	samplepos_t _natural_position;
 	std::string _format_name;
 
 	PBD::RingBuffer<Sample> _buffer;
-	// Set to 1 to indicate that ffmpeg should be terminating.
+	/* Set to 1 to indicate that ffmpeg should be terminating. */
 	GATOMIC_QUAL gint _ffmpeg_should_terminate;
 
-	// To make sure we don't try to parse partial floats, we might have a couple of bytes
+	/* To make sure we don't try to parse partial floats, we might have a couple of bytes
-	// of leftover unparsable data after any `did_read_data` call. Those couple of bytes are
+	 * of leftover unparsable data after any `did_read_data` call. Those couple of bytes are
-	// stored here until the next `did_read_data` call.
+	 * stored here until the next `did_read_data` call.
+	 */
 	std::string _leftover_data;
 
 	samplecnt_t _read_pos;
 
-	ARDOUR::SystemExec *_ffmpeg_exec;
+	ARDOUR::SystemExec*   _ffmpeg_exec;
 	PBD::ScopedConnection _ffmpeg_conn;
 };
 
-}
+} // namespace ARDOUR
 
 #endif /* _ardour_ffmpegfile_importable_source_h_ */

libs/ardour/ffmpegfileimportable.cc

@@ -19,21 +19,22 @@
 #include <boost/property_tree/json_parser.hpp>
 #include <glibmm.h>
 
-#include "pbd/error.h"
 #include "pbd/compose.h"
+#include "pbd/error.h"
 #include "pbd/i18n.h"
 
 #include "ardour/ffmpegfileimportable.h"
 #include "ardour/filesystem_paths.h"
 
-namespace ARDOUR {
+using namespace ARDOUR;
 
 static void
-receive_stdout (std::string* out, const std::string& data, size_t size) {
+receive_stdout (std::string* out, const std::string& data, size_t size)
+{
 	*out += data;
 }
 
-FFMPEGFileImportableSource::FFMPEGFileImportableSource(const std::string &path, int channel)
+FFMPEGFileImportableSource::FFMPEGFileImportableSource (const std::string& path, int channel)
 	: _path (path)
 	, _channel (channel)
 	, _buffer (32768)
@@ -44,11 +45,12 @@ FFMPEGFileImportableSource::FFMPEGFileImportableSource(const std::string &path,
 	std::string ffprobe_exe, unused;
 	if (!ArdourVideoToolPaths::transcoder_exe (unused, ffprobe_exe)) {
 		PBD::error << "FFMPEGFileImportableSource: Can't find ffprobe and ffmpeg" << endmsg;
-		throw failed_constructor();
+		throw failed_constructor ();
 	}
 
-	int a = 0;
+	int    a    = 0;
-	char **argp = (char **)calloc(10, sizeof(char *));
+	char** argp = (char**)calloc (10, sizeof (char*));
+
 	argp[a++] = strdup (ffprobe_exe.c_str ());
 	argp[a++] = strdup (_path.c_str ());
 	argp[a++] = strdup ("-show_streams");
@@ -61,55 +63,56 @@ FFMPEGFileImportableSource::FFMPEGFileImportableSource(const std::string &path,
 	if (exec->start ()) {
 		PBD::error << "FFMPEGFileImportableSource: External decoder (ffprobe) cannot be started." << endmsg;
 		delete exec;
-		throw failed_constructor();
+		throw failed_constructor ();
 	}
 
 	try {
 		PBD::ScopedConnection c;
-		std::string ffprobe_output;
+		std::string           ffprobe_output;
 		exec->ReadStdout.connect_same_thread (c, boost::bind (&receive_stdout, &ffprobe_output, _1, _2));
 
 		/* wait for ffprobe process to exit */
-		exec->wait();
+		exec->wait ();
 
 		namespace pt = boost::property_tree;
+		pt::ptree          root;
 		std::istringstream is (ffprobe_output);
-		pt::ptree root;
+
 		pt::read_json (is, root);
 
 		// TODO: Find the stream with the most channels, rather than whatever the first one is.
-		_channels = root.get<int> ("streams..channels");
+		_channels         = root.get<int> ("streams..channels");
-		_length = root.get<int64_t> ("streams..duration_ts");
+		_length           = root.get<int64_t> ("streams..duration_ts");
-		_samplerate = root.get<int> ("streams..sample_rate");
+		_samplerate       = root.get<int> ("streams..sample_rate");
 		_natural_position = root.get<int64_t> ("streams..start_pts");
-		_format_name = root.get<std::string> ("streams..codec_long_name");
+		_format_name      = root.get<std::string> ("streams..codec_long_name");
 		delete exec;
 	} catch (...) {
 		PBD::error << "FFMPEGFileImportableSource: Failed to read file metadata" << endmsg;
 		delete exec;
-		throw failed_constructor();
+		throw failed_constructor ();
 	}
 
-	if (_channel != ALL_CHANNELS && (_channel < 0 || _channel > (int) channels ())) {
+	if (_channel != ALL_CHANNELS && (_channel < 0 || _channel > (int)channels ())) {
-		PBD::error << string_compose("FFMPEGFileImportableSource: file only contains %1 channels; %2 is invalid as a channel number", channels(), _channel) << endmsg;
+		PBD::error << string_compose ("FFMPEGFileImportableSource: file only contains %1 channels; %2 is invalid as a channel number", channels (), _channel) << endmsg;
-		throw failed_constructor();
+		throw failed_constructor ();
 	}
 }
 
 FFMPEGFileImportableSource::~FFMPEGFileImportableSource ()
 {
-	reset();
+	reset ();
 }
 
 void
 FFMPEGFileImportableSource::seek (samplepos_t pos)
 {
 	if (pos < _read_pos) {
-		reset();
+		reset ();
 	}
 
 	if (!_ffmpeg_exec) {
-		start_ffmpeg();
+		start_ffmpeg ();
 	}
 
 	while (_read_pos < pos) {
@@ -124,7 +127,7 @@ FFMPEGFileImportableSource::seek (samplepos_t pos)
 			Glib::usleep (1000);
 			continue;
 		}
-		guint inc = std::min<guint>(read_space, pos - _read_pos);
+		guint inc = std::min<guint> (read_space, pos - _read_pos);
 		_buffer.increment_read_idx (inc);
 		_read_pos += inc;
 	}
@@ -134,7 +137,7 @@ samplecnt_t
 FFMPEGFileImportableSource::read (Sample* dst, samplecnt_t nframes)
 {
 	if (!_ffmpeg_exec) {
-		start_ffmpeg();
+		start_ffmpeg ();
 	}
 
 	samplecnt_t total_read = 0;
@@ -163,16 +166,16 @@ FFMPEGFileImportableSource::start_ffmpeg ()
 	std::string ffmpeg_exe, unused;
 	ArdourVideoToolPaths::transcoder_exe (ffmpeg_exe, unused);
 
-	int a = 0;
+	int    a    = 0;
-	char **argp = (char **)calloc(16, sizeof(char *));
+	char** argp = (char**)calloc (16, sizeof (char*));
-	char tmp[32];
+	char   tmp[32];
 	argp[a++] = strdup (ffmpeg_exe.c_str ());
 	argp[a++] = strdup ("-nostdin");
 	argp[a++] = strdup ("-i");
 	argp[a++] = strdup (_path.c_str ());
 	if (_channel != ALL_CHANNELS) {
 		argp[a++] = strdup ("-map_channel");
-		snprintf (tmp, sizeof(tmp), "0.0.%d", _channel);
+		snprintf (tmp, sizeof (tmp), "0.0.%d", _channel);
 		argp[a++] = strdup (tmp);
 	}
 	argp[a++] = strdup ("-f");
@@ -187,7 +190,7 @@ FFMPEGFileImportableSource::start_ffmpeg ()
 	PBD::info << "Decode command: { " << _ffmpeg_exec->to_s () << "}" << endmsg;
 	if (_ffmpeg_exec->start ()) {
 		PBD::error << "FFMPEGFileImportableSource: External decoder (ffmpeg) cannot be started." << endmsg;
-		throw std::runtime_error("Failed to start ffmpeg");
+		throw std::runtime_error ("Failed to start ffmpeg");
 	}
 
 	_ffmpeg_exec->ReadStdout.connect_same_thread (_ffmpeg_conn, boost::bind (&FFMPEGFileImportableSource::did_read_data, this, _1, _2));
@@ -210,11 +213,11 @@ void
 FFMPEGFileImportableSource::did_read_data (std::string data, size_t size)
 {
 	// Prepend the left-over data from a previous chunk of received data to this chunk.
-	data = _leftover_data + data;
+	data                  = _leftover_data + data;
-	samplecnt_t n_samples = data.length () / sizeof(float);
+	samplecnt_t n_samples = data.length () / sizeof (float);
 
 	// Stash leftover data.
-	_leftover_data = data.substr(n_samples * sizeof(float));
+	_leftover_data = data.substr (n_samples * sizeof (float));
 
 	const char* cur = data.data ();
 	while (n_samples > 0) {
@@ -232,14 +235,12 @@ FFMPEGFileImportableSource::did_read_data (std::string data, size_t size)
 
 		samplecnt_t written = 0;
 		for (int i = 0; i < 2; ++i) {
-			samplecnt_t cnt = std::min<samplecnt_t>(n_samples, wv.len[i]);
+			samplecnt_t cnt = std::min<samplecnt_t> (n_samples, wv.len[i]);
-			memcpy (wv.buf[i], cur, cnt * sizeof(float));
+			memcpy (wv.buf[i], cur, cnt * sizeof (float));
 			written += cnt;
 			n_samples -= cnt;
-			cur += cnt * sizeof(float);
+			cur += cnt * sizeof (float);
 		}
 		_buffer.increment_write_idx (written);
 	}
 }
-
-}