NO-OP: Whitespace

7 files changed, 76 insertions, 74 deletions

diff --git a/libs/ardour/ardour/disk_writer.h b/libs/ardour/ardour/disk_writer.h
index e3488141e3..343bf566ea 100644
--- a/libs/ardour/ardour/disk_writer.h
+++ b/libs/ardour/ardour/disk_writer.h
@@ -37,29 +37,29 @@ class MidiSource;
 
 class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 {
-  public:
+public:
 	DiskWriter (Session&, std::string const & name, DiskIOProcessor::Flag f = DiskIOProcessor::Flag (0));
 	~DiskWriter ();
 
 	bool set_name (std::string const & str);
 	std::string display_name() const { return std::string (_("recorder")); }
 
-	virtual bool set_write_source_name (const std::string& str);
-
-	bool           recordable()  const { return _flags & Recordable; }
+	bool               recordable()  const { return _flags & Recordable; }
 
 	static samplecnt_t chunk_samples() { return _chunk_samples; }
 	static samplecnt_t default_chunk_samples ();
-	static void set_chunk_samples (samplecnt_t n) { _chunk_samples = n; }
+	static void        set_chunk_samples (samplecnt_t n) { _chunk_samples = n; }
 
 	void run (BufferSet& /*bufs*/, samplepos_t /*start_sample*/, samplepos_t /*end_sample*/, double speed, pframes_t /*nframes*/, bool /*result_required*/);
+
 	void non_realtime_locate (samplepos_t);
 	void realtime_handle_transport_stopped ();
 
 	virtual XMLNode& state (bool full);
 	int set_state (const XMLNode&, int version);
 
-	std::string write_source_name () const {
+	virtual bool set_write_source_name (const std::string& str);
+	std::string  write_source_name () const {
 		if (_write_source_name.empty()) {
 			return name();
 		} else {
@@ -79,7 +79,7 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	boost::shared_ptr<SMFSource> midi_write_source () { return _midi_write_source; }
 
 	virtual std::string steal_write_source_name ();
-	int use_new_write_source (DataType, uint32_t n = 0);
+	int  use_new_write_source (DataType, uint32_t n = 0);
 	void reset_write_sources (bool, bool force = false);
 
 	AlignStyle alignment_style() const { return _alignment_style; }
@@ -97,8 +97,8 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	virtual void set_record_safe (bool yn);
 
 	bool destructive() const { return _flags & Destructive; }
-	int set_destructive (bool yn);
-	int set_non_layered (bool yn);
+	int  set_destructive (bool yn);
+	int  set_non_layered (bool yn);
 	bool can_become_destructive (bool& requires_bounce) const;
 
 	/** @return Start position of currently-running capture (in session samples) */
@@ -132,7 +132,7 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 
 	void adjust_buffering ();
 
-  protected:
+protected:
 	friend class Track;
 	int do_flush (RunContext context, bool force = false);
 
@@ -158,17 +158,18 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	mutable Glib::Threads::Mutex capture_info_lock;
 	CaptureInfos capture_info;
 
-  private:
+private:
 	gint         _record_enabled;
 	gint         _record_safe;
-	samplepos_t    capture_start_sample;
-	samplecnt_t    capture_captured;
-	bool          was_recording;
-	samplepos_t    first_recordable_sample;
-	samplepos_t    last_recordable_sample;
-	int           last_possibly_recording;
+	samplepos_t  capture_start_sample;
+	samplecnt_t  capture_captured;
+	bool         was_recording;
+	samplepos_t  first_recordable_sample;
+	samplepos_t  last_recordable_sample;
+	int          last_possibly_recording;
 	AlignStyle   _alignment_style;
-	std::string   _write_source_name;
+	std::string  _write_source_name;
+
 	boost::shared_ptr<SMFSource> _midi_write_source;
 
 	std::list<boost::shared_ptr<Source> > _last_capture_sources;
@@ -176,10 +177,10 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 
 	static samplecnt_t _chunk_samples;
 
-	NoteMode                     _note_mode;
-	volatile gint                _samples_pending_write;
-	volatile gint                _num_captured_loops;
-	samplepos_t                   _accumulated_capture_offset;
+	NoteMode           _note_mode;
+	volatile gint      _samples_pending_write;
+	volatile gint      _num_captured_loops;
+	samplepos_t        _accumulated_capture_offset;
 
 	/** A buffer that we use to put newly-arrived MIDI data in for
 	    the GUI to read (so that it can update itself).
diff --git a/libs/ardour/ardour/processor.h b/libs/ardour/ardour/processor.h
index 8f617abc19..3ba0730ba3 100644
--- a/libs/ardour/ardour/processor.h
+++ b/libs/ardour/ardour/processor.h
@@ -71,10 +71,10 @@ class LIBARDOUR_API Processor : public SessionObject, public Automatable, public
 	virtual samplecnt_t signal_latency() const { return 0; }
 
 	virtual void set_input_latency (samplecnt_t cnt) { _input_latency = cnt; }
-	samplecnt_t input_latency () const { return _input_latency; }
+	samplecnt_t input_latency () const               { return _input_latency; }
 
 	virtual void set_output_latency (samplecnt_t cnt) { _output_latency = cnt; }
-	samplecnt_t output_latency () const { return _output_latency; }
+	samplecnt_t output_latency () const               { return _output_latency; }
 
 	virtual int set_block_size (pframes_t /*nframes*/) { return 0; }
 	virtual bool requires_fixed_sized_buffers() const { return false; }
diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 693bbd157a..15eb786ed2 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -351,9 +351,9 @@ public:
 	samplecnt_t initial_delay() const  { return _initial_delay; }
 	samplecnt_t signal_latency() const { return _signal_latency; }
 
-	PBD::Signal0<void>       active_changed;
-	PBD::Signal0<void>       denormal_protection_changed;
-	PBD::Signal0<void>       comment_changed;
+	PBD::Signal0<void> active_changed;
+	PBD::Signal0<void> denormal_protection_changed;
+	PBD::Signal0<void> comment_changed;
 
 	/** track numbers - assigned by session
 	 * nubers > 0 indicate tracks (audio+midi)
@@ -618,28 +618,30 @@ public:
 															 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 	                             bool for_export, bool for_freeze);
 
-	samplecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
+	samplecnt_t  bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 	ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 
-	boost::shared_ptr<IO> _input;
-	boost::shared_ptr<IO> _output;
-
 	bool           _active;
 	samplecnt_t     _signal_latency;
 	samplecnt_t     _initial_delay;
 
 	ProcessorList  _processors;
-	mutable Glib::Threads::RWLock   _processor_lock;
-	boost::shared_ptr<Delivery> _main_outs;
-	boost::shared_ptr<InternalSend> _monitor_send;
-	boost::shared_ptr<InternalReturn> _intreturn;
+	mutable Glib::Threads::RWLock _processor_lock;
+
+	boost::shared_ptr<IO>               _input;
+	boost::shared_ptr<IO>               _output;
+
+	boost::shared_ptr<Delivery>         _main_outs;
+	boost::shared_ptr<InternalSend>     _monitor_send;
+	boost::shared_ptr<InternalReturn>   _intreturn;
 	boost::shared_ptr<MonitorProcessor> _monitor_control;
-	boost::shared_ptr<Pannable> _pannable;
-	boost::shared_ptr<DiskReader> _disk_reader;
-	boost::shared_ptr<DiskWriter> _disk_writer;
-	boost::shared_ptr<MonitorControl> _monitoring_control;
+	boost::shared_ptr<Pannable>         _pannable;
+	boost::shared_ptr<DiskReader>       _disk_reader;
+	boost::shared_ptr<DiskWriter>       _disk_writer;
 
-	DiskIOPoint    _disk_io_point;
+	boost::shared_ptr<MonitorControl>   _monitoring_control;
+
+	DiskIOPoint _disk_io_point;
 
 	enum {
 		EmitNone = 0x00,
@@ -701,6 +703,7 @@ public:
 	boost::shared_ptr<GainControl> _trim_control;
 	boost::shared_ptr<Amp>       _trim;
 	boost::shared_ptr<PeakMeter> _meter;
+
 	boost::shared_ptr<DelayLine> _delayline;
 
 	bool is_internal_processor (boost::shared_ptr<Processor>) const;
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 43336c2465..69c823720c 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -474,7 +474,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	int location_name(std::string& result, std::string base = std::string(""));
 
 	pframes_t get_block_size () const            { return current_block_size; }
-	samplecnt_t worst_output_latency ()const     { return _worst_output_latency; }
+	samplecnt_t worst_output_latency () const    { return _worst_output_latency; }
 	samplecnt_t worst_input_latency () const     { return _worst_input_latency; }
 	samplecnt_t worst_track_latency () const     { return _worst_track_latency; }
 	samplecnt_t worst_track_out_latency () const { return _worst_track_out_latency; }
@@ -678,8 +678,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	/* Time */
 
-	samplepos_t transport_sample () const {return _transport_sample; }
-	samplepos_t record_location () const {return _last_record_location; }
+	samplepos_t transport_sample () const { return _transport_sample; }
+	samplepos_t record_location () const { return _last_record_location; }
 	samplepos_t audible_sample (bool* latent_locate = NULL) const;
 	samplepos_t requested_return_sample() const { return _requested_return_sample; }
 	void set_requested_return_sample(samplepos_t return_to);
@@ -1238,11 +1238,11 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	bool                    _bounce_processing_active;
 	bool                     waiting_for_sync_offset;
 	samplecnt_t              _base_sample_rate;     // sample-rate of the session at creation time, "native" SR
-	samplecnt_t              _nominal_sample_rate;  // overridden by audioengine setting
-	samplecnt_t              _current_sample_rate;  // this includes video pullup offset
+	samplecnt_t             _nominal_sample_rate;  // overridden by audioengine setting
+	samplecnt_t             _current_sample_rate;  // this includes video pullup offset
 	int                      transport_sub_state;
 	mutable gint            _record_status;
-	samplepos_t              _transport_sample;
+	samplepos_t             _transport_sample;
 	gint                    _seek_counter;
 	Location*               _session_range_location; ///< session range, or 0 if there is nothing in the session yet
 	bool                    _session_range_end_is_free;
diff --git a/libs/ardour/disk_writer.cc b/libs/ardour/disk_writer.cc
index 24e2a7e85c..c05b19a12c 100644
--- a/libs/ardour/disk_writer.cc
+++ b/libs/ardour/disk_writer.cc
@@ -204,9 +204,9 @@ DiskWriter::calculate_record_range (Evoral::OverlapType ot, samplepos_t transpor
 		break;
 	}
 
-        DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 rec? %2 @ %3 (for %4) FRF %5 LRF %6 : rf %7 @ %8\n",
-                                                              _name, enum_2_string (ot), transport_sample, nframes,
-                                                              first_recordable_sample, last_recordable_sample, rec_nframes, rec_offset));
+	DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 rec? %2 @ %3 (for %4) FRF %5 LRF %6 : rf %7 @ %8\n",
+	                                                      _name, enum_2_string (ot), transport_sample, nframes,
+	                                                      first_recordable_sample, last_recordable_sample, rec_nframes, rec_offset));
 }
 
 void
@@ -312,10 +312,10 @@ DiskWriter::non_realtime_locate (samplepos_t position)
 
 
 void
-DiskWriter::prepare_record_status(samplepos_t capture_start_sample)
+DiskWriter::prepare_record_status (samplepos_t capture_start_sample)
 {
 	if (recordable() && destructive()) {
-		boost::shared_ptr<ChannelList> c = channels.reader();
+		boost::shared_ptr<ChannelList> c = channels.reader ();
 		for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 
 			RingBufferNPT<CaptureTransition>::rw_vector transitions;
@@ -387,9 +387,9 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 	}
 
 	const Location* const loop_loc    = loop_location;
-	samplepos_t            loop_start  = 0;
-	samplepos_t            loop_end    = 0;
-	samplepos_t            loop_length = 0;
+	samplepos_t           loop_start  = 0;
+	samplepos_t           loop_end    = 0;
+	samplepos_t           loop_length = 0;
 
 	if (loop_loc) {
 		get_location_times (loop_loc, &loop_start, &loop_end, &loop_length);
@@ -413,7 +413,7 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 				   at the loop start and can handle time wrapping around.
 				   Otherwise, start the source right now as usual.
 				*/
-				capture_captured    = start_sample - loop_start;
+				capture_captured     = start_sample - loop_start;
 				capture_start_sample = loop_start;
 			}
 
@@ -421,8 +421,8 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 				_midi_write_source->mark_write_starting_now (capture_start_sample, capture_captured, loop_length);
 			}
 
-			g_atomic_int_set(const_cast<gint*> (&_samples_pending_write), 0);
-			g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
+			g_atomic_int_set (const_cast<gint*> (&_samples_pending_write), 0);
+			g_atomic_int_set (const_cast<gint*> (&_num_captured_loops), 0);
 
 			was_recording = true;
 
@@ -440,7 +440,7 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 
 	}
 
-	if (can_record && !_last_capture_sources.empty()) {
+	if (can_record && !_last_capture_sources.empty ()) {
 		_last_capture_sources.clear ();
 	}
 
@@ -467,9 +467,9 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 				samplecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
 
 				if (rec_nframes > total) {
-                                        DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
-                                                                                    DEBUG_THREAD_SELF, name(), rec_nframes, total));
-                                        Overrun ();
+					DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
+					                                            DEBUG_THREAD_SELF, name(), rec_nframes, total));
+					Overrun ();
 					return;
 				}
 
@@ -492,7 +492,7 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 		MidiChannelFilter* filter = mt ? &mt->capture_filter() : 0;
 
 		for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
-			Evoral::Event<MidiBuffer::TimeType> ev(*i, false);
+			Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
 			if (ev.time() + rec_offset > rec_nframes) {
 				break;
 			}
@@ -531,7 +531,7 @@ DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp
 				_midi_buf->write (event_time, ev.event_type(), ev.size(), ev.buffer());
 			}
 		}
-		g_atomic_int_add(const_cast<gint*>(&_samples_pending_write), nframes);
+		g_atomic_int_add (const_cast<gint*>(&_samples_pending_write), nframes);
 
 		if (buf.size() != 0) {
 			Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index 4eae23bd19..a0d6676b22 100644
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -3346,19 +3346,17 @@ Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
 void
 Route::non_realtime_transport_stop (samplepos_t now, bool flush)
 {
-	{
-		Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
-
-		Automatable::non_realtime_transport_stop (now, flush);
+	Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 
-		for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+	Automatable::non_realtime_transport_stop (now, flush);
 
-			if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
-				(*i)->flush ();
-			}
+	for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 
-			(*i)->non_realtime_transport_stop (now, flush);
+		if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
+			(*i)->flush ();
 		}
+
+		(*i)->non_realtime_transport_stop (now, flush);
 	}
 }
 
diff --git a/libs/ardour/send.cc b/libs/ardour/send.cc
index c5ad4d8ed7..ca5c49585f 100644
--- a/libs/ardour/send.cc
+++ b/libs/ardour/send.cc
@@ -107,7 +107,7 @@ Send::Send (Session& s, boost::shared_ptr<Pannable> p, boost::shared_ptr<MuteMas
 
 Send::~Send ()
 {
-        _session.unmark_send_id (_bitslot);
+	_session.unmark_send_id (_bitslot);
 }
 
 void
@@ -397,7 +397,7 @@ Send::display_to_user () const
 	/* we ignore Deliver::_display_to_user */
 
 	if (_role == Listen) {
-                /* don't make the monitor/control/listen send visible */
+		/* don't make the monitor/control/listen send visible */
 		return false;
 	}