NO-OP: Whitespace

diff --git a/libs/ardour/ardour/disk_writer.h b/libs/ardour/ardour/disk_writer.h
index e3488141e3ee6c2846f0dad1db365dd11f7d6a80..343bf566ea3a20b20cf72a2223dca2aa95dca5ca 100644 (file)
--- 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 8f617abc19d8d525de840d226d76471f2a93d852..3ba0730ba37b7fd4540557af10d21f315636439e 100644 (file)
--- 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 693bbd157a650ae8a7040e62d8c70e76ebec4194..15eb786ed2c4ecd8e63e3b88a52e94068d6a98ec 100644 (file)
--- 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 43336c2465666a25238f8f6ad46d824df6e35511..69c823720c0d2580f60cae916ae1bef97e51a477 100644 (file)
--- 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 24e2a7e85c9bdbd6de3905cfb94ff00e2d79ba50..c05b19a12c428acd49062dd0be3654a383e70a82 100644 (file)
--- 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 4eae23bd1999362eedfa55d4cae5a84d7be27583..a0d6676b223a8b11e5269255cea7db04253a270b 100644 (file)
--- 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 c5ad4d8ed7a2dbd3b9898e0ef86a8636cc1fd4e3..ca5c49585f0258f0ec9224db18b542adeea9a568 100644 (file)
--- 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;
        }