NO-OP: whitespace

diff --git a/libs/ardour/ardour/audio_port.h b/libs/ardour/ardour/audio_port.h
index 4224a88d558bbb15f1009c9390c5b90468e10324..4f106c5593000328f8f34e2bb5c1e328da5972e5 100644 (file)
--- a/libs/ardour/ardour/audio_port.h
+++ b/libs/ardour/ardour/audio_port.h
@@ -30,7 +30,7 @@ namespace ARDOUR {
 
 class LIBARDOUR_API AudioPort : public Port
 {
-   public:
+public:
        ~AudioPort ();
 
        DataType type () const {
@@ -47,14 +47,14 @@ class LIBARDOUR_API AudioPort : public Port
 
        AudioBuffer& get_audio_buffer (pframes_t nframes);
 
-  protected:
+protected:
        friend class PortManager;
        AudioPort (std::string const &, PortFlags);
 
        /* special access for PortManager only (hah, C++) */
        Sample* engine_get_whole_audio_buffer ();
 
-  private:
+private:
        AudioBuffer*            _buffer;
        ArdourZita::VMResampler _src;
        Sample*                 _data;

diff --git a/libs/ardour/port.cc b/libs/ardour/port.cc
index b469194ea5cdf702b1136712e0dd484771e5cb2a..3ae3063b299265f5563878a922e6bdea278a4696 100644 (file)
--- a/libs/ardour/port.cc
+++ b/libs/ardour/port.cc
@@ -342,13 +342,13 @@ Port::reset ()
 void
 Port::cycle_start (pframes_t)
 {
-        _port_buffer_offset = 0;
+       _port_buffer_offset = 0;
 }
 
 void
 Port::increment_port_buffer_offset (pframes_t nframes)
 {
-        _port_buffer_offset += nframes;
+       _port_buffer_offset += nframes;
 }
 
 void
@@ -463,57 +463,57 @@ Port::get_connected_latency_range (LatencyRange& range, bool playback) const
                DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: %2 connections to check for latency range\n", name(), connections.size()));
 
                for (vector<string>::const_iterator c = connections.begin();
-                    c != connections.end(); ++c) {
+                               c != connections.end(); ++c) {
 
-                        LatencyRange lr;
+                       LatencyRange lr;
 
-                        if (!AudioEngine::instance()->port_is_mine (*c)) {
+                       if (!AudioEngine::instance()->port_is_mine (*c)) {
 
-                                /* port belongs to some other port-system client, use
-                                 * the port engine to lookup its latency information.
-                                 */
+                               /* port belongs to some other port-system client, use
+                                * the port engine to lookup its latency information.
+                                */
 
                                PortEngine::PortHandle remote_port = port_engine.get_port_by_name (*c);
 
-                                if (remote_port) {
-                                        lr = port_engine.get_latency_range (remote_port, playback);
-                                        if (externally_connected ()) {
+                               if (remote_port) {
+                                       lr = port_engine.get_latency_range (remote_port, playback);
+                                       if (externally_connected ()) {
 #if 0
-                                          lr.min /= _speed_ratio;
-                                          lr.max /= _speed_ratio;
+                                               lr.min /= _speed_ratio;
+                                               lr.max /= _speed_ratio;
 #endif
-                                          lr.min += (_resampler_quality - 1);
-                                          lr.max += (_resampler_quality - 1);
-                                        }
+                                               lr.min += (_resampler_quality - 1);
+                                               lr.max += (_resampler_quality - 1);
+                                       }
 
-                                        DEBUG_TRACE (DEBUG::Latency, string_compose (
-                                                             "\t%1 <-> %2 : latter has latency range %3 .. %4\n",
-                                                             name(), *c, lr.min, lr.max));
+                                       DEBUG_TRACE (DEBUG::Latency, string_compose (
+                                                               "\t%1 <-> %2 : latter has latency range %3 .. %4\n",
+                                                               name(), *c, lr.min, lr.max));
 
-                                        range.min = min (range.min, lr.min);
-                                        range.max = max (range.max, lr.max);
-                                }
+                                       range.min = min (range.min, lr.min);
+                                       range.max = max (range.max, lr.max);
+                               }
 
                        } else {
 
-                                /* port belongs to this instance of ardour,
-                                   so look up its latency information
-                                   internally, because our published/public
-                                   values already contain our plugin
-                                   latency compensation.
-                                */
-
-                                boost::shared_ptr<Port> remote_port = AudioEngine::instance()->get_port_by_name (*c);
-                                if (remote_port) {
-                                        lr = remote_port->private_latency_range ((playback ? true : false));
-                                        DEBUG_TRACE (DEBUG::Latency, string_compose (
-                                                             "\t%1 <-LOCAL-> %2 : latter has latency range %3 .. %4\n",
-                                                             name(), *c, lr.min, lr.max));
-
-                                        range.min = min (range.min, lr.min);
-                                        range.max = max (range.max, lr.max);
-                                }
-                        }
+                               /* port belongs to this instance of ardour,
+                                        so look up its latency information
+                                        internally, because our published/public
+                                        values already contain our plugin
+                                        latency compensation.
+                                        */
+
+                               boost::shared_ptr<Port> remote_port = AudioEngine::instance()->get_port_by_name (*c);
+                               if (remote_port) {
+                                       lr = remote_port->private_latency_range ((playback ? true : false));
+                                       DEBUG_TRACE (DEBUG::Latency, string_compose (
+                                                               "\t%1 <-LOCAL-> %2 : latter has latency range %3 .. %4\n",
+                                                               name(), *c, lr.min, lr.max));
+
+                                       range.min = min (range.min, lr.min);
+                                       range.max = max (range.max, lr.max);
+                               }
+                       }
                }
 
        } else {
@@ -522,7 +522,7 @@ Port::get_connected_latency_range (LatencyRange& range, bool playback) const
                range.max = 0;
        }
 
-        DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: final connected latency range [ %2 .. %3 ] \n", name(), range.min, range.max));
+       DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: final connected latency range [ %2 .. %3 ] \n", name(), range.min, range.max));
 }
 
 int

diff --git a/libs/ardour/port_manager.cc b/libs/ardour/port_manager.cc
index 6d3336cabbc909dec0b294c9520d810fc7840884..1ef7ca1d8b7d10e34fcd000b4c9ff2501bea5b7c 100644 (file)
--- a/libs/ardour/port_manager.cc
+++ b/libs/ardour/port_manager.cc
@@ -166,11 +166,11 @@ PortManager::port_is_mine (const string& portname) const
 
        if (portname.find_first_of (':') != string::npos) {
                if (portname.substr (0, self.length ()) != self) {
-                        return false;
-                }
-        }
+                       return false;
+               }
+       }
 
-        return true;
+       return true;
 }
 
 bool
@@ -270,7 +270,6 @@ PortManager::n_physical_inputs () const
 /** @param name Full or short name of port
  *  @return Corresponding Port or 0.
  */
-
 boost::shared_ptr<Port>
 PortManager::get_port_by_name (const string& portname)
 {
@@ -278,10 +277,10 @@ PortManager::get_port_by_name (const string& portname)
                return boost::shared_ptr<Port>();
        }
 
-        if (!port_is_mine (portname)) {
-                /* not an ardour port */
-                return boost::shared_ptr<Port> ();
-        }
+       if (!port_is_mine (portname)) {
+               /* not an ardour port */
+               return boost::shared_ptr<Port> ();
+       }
 
        boost::shared_ptr<Ports> pr = ports.reader();
        std::string rel = make_port_name_relative (portname);
@@ -289,10 +288,10 @@ PortManager::get_port_by_name (const string& portname)
 
        if (x != pr->end()) {
                /* its possible that the port was renamed by some 3rd party and
-                  we don't know about it. check for this (the check is quick
-                  and cheap), and if so, rename the port (which will alter
-                  the port map as a side effect).
-               */
+                * we don't know about it. check for this (the check is quick
+                * and cheap), and if so, rename the port (which will alter
+                * the port map as a side effect).
+                */
                const std::string check = make_port_name_relative (_backend->get_port_name (x->second->port_handle()));
                if (check != rel) {
                        x->second->set_name (check);
@@ -300,7 +299,7 @@ PortManager::get_port_by_name (const string& portname)
                return x->second;
        }
 
-        return boost::shared_ptr<Port> ();
+       return boost::shared_ptr<Port> ();
 }
 
 void