libs/ardour/session.cc

   1 /*
   2     Copyright (C) 1999-2010 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <stdint.h>
  21
  22 #include <algorithm>
  23 #include <string>
  24 #include <vector>
  25 #include <sstream>
  26 #include <fstream>
  27 #include <cstdio> /* sprintf(3) ... grrr */
  28 #include <cmath>
  29 #include <cerrno>
  30 #include <unistd.h>
  31 #include <limits.h>
  32
  33 #include <glibmm/threads.h>
  34 #include <glibmm/miscutils.h>
  35 #include <glibmm/fileutils.h>
  36
  37 #include <boost/algorithm/string/erase.hpp>
  38
  39 #include "pbd/error.h"
  40 #include "pbd/boost_debug.h"
  41 #include "pbd/pathscanner.h"
  42 #include "pbd/stl_delete.h"
  43 #include "pbd/basename.h"
  44 #include "pbd/stacktrace.h"
  45 #include "pbd/file_utils.h"
  46 #include "pbd/convert.h"
  47 #include "pbd/strsplit.h"
  48 #include "pbd/unwind.h"
  49
  50 #include "ardour/amp.h"
  51 #include "ardour/analyser.h"
  52 #include "ardour/audio_buffer.h"
  53 #include "ardour/audio_diskstream.h"
  54 #include "ardour/audio_port.h"
  55 #include "ardour/audio_track.h"
  56 #include "ardour/audioengine.h"
  57 #include "ardour/audiofilesource.h"
  58 #include "ardour/auditioner.h"
  59 #include "ardour/buffer_manager.h"
  60 #include "ardour/buffer_set.h"
  61 #include "ardour/bundle.h"
  62 #include "ardour/butler.h"
  63 #include "ardour/click.h"
  64 #include "ardour/control_protocol_manager.h"
  65 #include "ardour/data_type.h"
  66 #include "ardour/debug.h"
  67 #include "ardour/filename_extensions.h"
  68 #include "ardour/graph.h"
  69 #include "ardour/midi_track.h"
  70 #include "ardour/midi_ui.h"
  71 #include "ardour/operations.h"
  72 #include "ardour/playlist.h"
  73 #include "ardour/plugin.h"
  74 #include "ardour/plugin_insert.h"
  75 #include "ardour/process_thread.h"
  76 #include "ardour/rc_configuration.h"
  77 #include "ardour/recent_sessions.h"
  78 #include "ardour/region.h"
  79 #include "ardour/region_factory.h"
  80 #include "ardour/route_graph.h"
  81 #include "ardour/route_group.h"
  82 #include "ardour/send.h"
  83 #include "ardour/session.h"
  84 #include "ardour/session_directory.h"
  85 #include "ardour/session_playlists.h"
  86 #include "ardour/smf_source.h"
  87 #include "ardour/source_factory.h"
  88 #include "ardour/utils.h"
  89
  90 #include "midi++/port.h"
  91 #include "midi++/jack_midi_port.h"
  92 #include "midi++/mmc.h"
  93 #include "midi++/manager.h"
  94
  95 #include "i18n.h"
  96
  97 namespace ARDOUR {
  98 class MidiSource;
  99 class Processor;
 100 class Speakers;
 101 }
 102
 103 using namespace std;
 104 using namespace ARDOUR;
 105 using namespace PBD;
 106
 107 bool Session::_disable_all_loaded_plugins = false;
 108
 109 PBD::Signal1<void,std::string> Session::Dialog;
 110 PBD::Signal0<int> Session::AskAboutPendingState;
 111 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
 112 PBD::Signal0<void> Session::SendFeedback;
 113 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
 114
 115 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
 116 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
 117 PBD::Signal2<void,std::string, std::string> Session::Exported;
 118 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
 119 PBD::Signal0<void> Session::Quit;
 120 PBD::Signal0<void> Session::FeedbackDetected;
 121 PBD::Signal0<void> Session::SuccessfulGraphSort;
 122 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
 123
 124 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
 125 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
 126
 127 /** @param snapshot_name Snapshot name, without .ardour suffix */
 128 Session::Session (AudioEngine &eng,
 129                   const string& fullpath,
 130                   const string& snapshot_name,
 131                   BusProfile* bus_profile,
 132                   string mix_template)
 133         : _engine (eng)
 134         , _target_transport_speed (0.0)
 135         , _requested_return_frame (-1)
 136         , _under_nsm_control (false)
 137         , _session_dir (new SessionDirectory(fullpath))
 138         , state_tree (0)
 139         , _state_of_the_state (Clean)
 140         , _butler (new Butler (*this))
 141         , _post_transport_work (0)
 142         , _send_timecode_update (false)
 143         , _all_route_group (new RouteGroup (*this, "all"))
 144         , routes (new RouteList)
 145         , _total_free_4k_blocks (0)
 146         , _total_free_4k_blocks_uncertain (false)
 147         , _bundles (new BundleList)
 148         , _bundle_xml_node (0)
 149         , _current_trans (0)
 150         , click_data (0)
 151         , click_emphasis_data (0)
 152         , main_outs (0)
 153         , _have_rec_enabled_track (false)
 154         , _suspend_timecode_transmission (0)
 155 {
 156         _locations = new Locations (*this);
 157         ltc_encoder = NULL;
 158
 159         if (how_many_dsp_threads () > 1) {
 160                 /* For now, only create the graph if we are using >1 DSP threads, as
 161                    it is a bit slower than the old code with 1 thread.
 162                 */
 163                 _process_graph.reset (new Graph (*this));
 164         }
 165
 166         playlists.reset (new SessionPlaylists);
 167
 168         _all_route_group->set_active (true, this);
 169
 170         interpolation.add_channel_to (0, 0);
 171
 172         if (!eng.connected()) {
 173                 throw failed_constructor();
 174         }
 175
 176         n_physical_outputs = _engine.n_physical_outputs ();
 177         n_physical_inputs =  _engine.n_physical_inputs ();
 178
 179         first_stage_init (fullpath, snapshot_name);
 180
 181         _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
 182
 183         if (_is_new) {
 184                 if (create (mix_template, bus_profile)) {
 185                         destroy ();
 186                         throw failed_constructor ();
 187                 }
 188         }
 189
 190         if (second_stage_init ()) {
 191                 destroy ();
 192                 throw failed_constructor ();
 193         }
 194
 195         store_recent_sessions(_name, _path);
 196
 197         bool was_dirty = dirty();
 198
 199         _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 200
 201         Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
 202         config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
 203
 204         if (was_dirty) {
 205                 DirtyChanged (); /* EMIT SIGNAL */
 206         }
 207
 208         StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
 209         EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
 210
 211         _is_new = false;
 212 }
 213
 214 Session::~Session ()
 215 {
 216 #ifdef PT_TIMING
 217         ST.dump ("ST.dump");
 218 #endif
 219         destroy ();
 220 }
 221
 222 void
 223 Session::destroy ()
 224 {
 225         vector<void*> debug_pointers;
 226
 227         /* if we got to here, leaving pending capture state around
 228            is a mistake.
 229         */
 230
 231         remove_pending_capture_state ();
 232
 233         _state_of_the_state = StateOfTheState (CannotSave|Deletion);
 234
 235         /* disconnect from any and all signals that we are connected to */
 236
 237         drop_connections ();
 238
 239         _engine.remove_session ();
 240
 241         /* deregister all ports - there will be no process or any other
 242          * callbacks from the engine any more.
 243          */
 244
 245         Port::PortDrop (); /* EMIT SIGNAL */
 246
 247         ltc_tx_cleanup();
 248
 249         /* clear history so that no references to objects are held any more */
 250
 251         _history.clear ();
 252
 253         /* clear state tree so that no references to objects are held any more */
 254
 255         delete state_tree;
 256
 257         /* reset dynamic state version back to default */
 258
 259         Stateful::loading_state_version = 0;
 260
 261         _butler->drop_references ();
 262         delete _butler;
 263         _butler = 0;
 264
 265         delete midi_control_ui;
 266         delete _all_route_group;
 267
 268         if (click_data != default_click) {
 269                 delete [] click_data;
 270         }
 271
 272         if (click_emphasis_data != default_click_emphasis) {
 273                 delete [] click_emphasis_data;
 274         }
 275
 276         clear_clicks ();
 277
 278         /* clear out any pending dead wood from RCU managed objects */
 279
 280         routes.flush ();
 281         _bundles.flush ();
 282
 283         AudioDiskstream::free_working_buffers();
 284
 285         /* tell everyone who is still standing that we're about to die */
 286         drop_references ();
 287
 288         /* tell everyone to drop references and delete objects as we go */
 289
 290         DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
 291         RegionFactory::delete_all_regions ();
 292
 293         DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
 294
 295         /* reset these three references to special routes before we do the usual route delete thing */
 296
 297         auditioner.reset ();
 298         _master_out.reset ();
 299         _monitor_out.reset ();
 300
 301         {
 302                 RCUWriter<RouteList> writer (routes);
 303                 boost::shared_ptr<RouteList> r = writer.get_copy ();
 304
 305                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 306                         DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
 307                         (*i)->drop_references ();
 308                 }
 309
 310                 r->clear ();
 311                 /* writer goes out of scope and updates master */
 312         }
 313         routes.flush ();
 314
 315         DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
 316         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 317                 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
 318                 i->second->drop_references ();
 319         }
 320
 321         sources.clear ();
 322
 323         DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
 324         for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
 325
 326                 delete *i;
 327         }
 328
 329         /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
 330         playlists.reset ();
 331
 332         delete _locations;
 333
 334         DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
 335
 336 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
 337         boost_debug_list_ptrs ();
 338 #endif
 339 }
 340
 341 void
 342 Session::when_engine_running ()
 343 {
 344         string first_physical_output;
 345
 346         BootMessage (_("Set block size and sample rate"));
 347
 348         set_block_size (_engine.frames_per_cycle());
 349         set_frame_rate (_engine.frame_rate());
 350
 351         BootMessage (_("Using configuration"));
 352
 353         boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
 354         boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
 355
 356         Config->map_parameters (ff);
 357         config.map_parameters (ft);
 358
 359         /* every time we reconnect, recompute worst case output latencies */
 360
 361         _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
 362
 363         if (synced_to_jack()) {
 364                 _engine.transport_stop ();
 365         }
 366
 367         if (config.get_jack_time_master()) {
 368                 _engine.transport_locate (_transport_frame);
 369         }
 370
 371         _clicking = false;
 372
 373         try {
 374                 XMLNode* child = 0;
 375
 376                 _ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
 377                 _ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
 378
 379                 if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
 380                         _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
 381                 } else {
 382                         {
 383                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 384                                 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
 385                         }
 386                         reconnect_ltc_input ();
 387                 }
 388
 389                 if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
 390                         _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
 391                 } else {
 392                         {
 393                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 394                                 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
 395                         }
 396                         reconnect_ltc_output ();
 397                 }
 398
 399                 /* fix up names of LTC ports because we don't want the normal
 400                  * IO style of NAME/TYPE-{in,out}N
 401                  */
 402
 403                 _ltc_input->nth (0)->set_name (_("LTC-in"));
 404                 _ltc_output->nth (0)->set_name (_("LTC-out"));
 405
 406                 _click_io.reset (new ClickIO (*this, "click"));
 407                 _click_gain.reset (new Amp (*this));
 408                 _click_gain->activate ();
 409
 410                 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
 411
 412                         /* existing state for Click */
 413                         int c = 0;
 414
 415                         if (Stateful::loading_state_version < 3000) {
 416                                 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
 417                         } else {
 418                                 const XMLNodeList& children (child->children());
 419                                 XMLNodeList::const_iterator i = children.begin();
 420                                 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
 421                                         ++i;
 422                                         if (i != children.end()) {
 423                                                 c = _click_gain->set_state (**i, Stateful::loading_state_version);
 424                                         }
 425                                 }
 426                         }
 427
 428                         if (c == 0) {
 429                                 _clicking = Config->get_clicking ();
 430
 431                         } else {
 432
 433                                 error << _("could not setup Click I/O") << endmsg;
 434                                 _clicking = false;
 435                         }
 436
 437
 438                 } else {
 439
 440                         /* default state for Click: dual-mono to first 2 physical outputs */
 441
 442                         vector<string> outs;
 443                         _engine.get_physical_outputs (DataType::AUDIO, outs);
 444
 445                         for (uint32_t physport = 0; physport < 2; ++physport) {
 446                                 if (outs.size() > physport) {
 447                                         if (_click_io->add_port (outs[physport], this)) {
 448                                                 // relax, even though its an error
 449                                         }
 450                                 }
 451                         }
 452
 453                         if (_click_io->n_ports () > ChanCount::ZERO) {
 454                                 _clicking = Config->get_clicking ();
 455                         }
 456                 }
 457         }
 458
 459         catch (failed_constructor& err) {
 460                 error << _("cannot setup Click I/O") << endmsg;
 461         }
 462
 463         BootMessage (_("Compute I/O Latencies"));
 464
 465         if (_clicking) {
 466                 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
 467         }
 468
 469         BootMessage (_("Set up standard connections"));
 470
 471         vector<string> inputs[DataType::num_types];
 472         vector<string> outputs[DataType::num_types];
 473         for (uint32_t i = 0; i < DataType::num_types; ++i) {
 474                 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
 475                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
 476         }
 477
 478         /* Create a set of Bundle objects that map
 479            to the physical I/O currently available.  We create both
 480            mono and stereo bundles, so that the common cases of mono
 481            and stereo tracks get bundles to put in their mixer strip
 482            in / out menus.  There may be a nicer way of achieving that;
 483            it doesn't really scale that well to higher channel counts
 484         */
 485
 486         /* mono output bundles */
 487
 488         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
 489                 char buf[32];
 490                 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
 491
 492                 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
 493                 c->add_channel (_("mono"), DataType::AUDIO);
 494                 c->set_port (0, outputs[DataType::AUDIO][np]);
 495
 496                 add_bundle (c);
 497         }
 498
 499         /* stereo output bundles */
 500
 501         for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
 502                 if (np + 1 < outputs[DataType::AUDIO].size()) {
 503                         char buf[32];
 504                         snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
 505                         boost::shared_ptr<Bundle> c (new Bundle (buf, true));
 506                         c->add_channel (_("L"), DataType::AUDIO);
 507                         c->set_port (0, outputs[DataType::AUDIO][np]);
 508                         c->add_channel (_("R"), DataType::AUDIO);
 509                         c->set_port (1, outputs[DataType::AUDIO][np + 1]);
 510
 511                         add_bundle (c);
 512                 }
 513         }
 514
 515         /* mono input bundles */
 516
 517         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
 518                 char buf[32];
 519                 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
 520
 521                 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
 522                 c->add_channel (_("mono"), DataType::AUDIO);
 523                 c->set_port (0, inputs[DataType::AUDIO][np]);
 524
 525                 add_bundle (c);
 526         }
 527
 528         /* stereo input bundles */
 529
 530         for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
 531                 if (np + 1 < inputs[DataType::AUDIO].size()) {
 532                         char buf[32];
 533                         snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
 534
 535                         boost::shared_ptr<Bundle> c (new Bundle (buf, false));
 536                         c->add_channel (_("L"), DataType::AUDIO);
 537                         c->set_port (0, inputs[DataType::AUDIO][np]);
 538                         c->add_channel (_("R"), DataType::AUDIO);
 539                         c->set_port (1, inputs[DataType::AUDIO][np + 1]);
 540
 541                         add_bundle (c);
 542                 }
 543         }
 544
 545         /* MIDI input bundles */
 546
 547         for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
 548                 string n = inputs[DataType::MIDI][np];
 549                 boost::erase_first (n, X_("alsa_pcm:"));
 550
 551                 boost::shared_ptr<Bundle> c (new Bundle (n, false));
 552                 c->add_channel ("", DataType::MIDI);
 553                 c->set_port (0, inputs[DataType::MIDI][np]);
 554                 add_bundle (c);
 555         }
 556
 557         /* MIDI output bundles */
 558
 559         for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
 560                 string n = outputs[DataType::MIDI][np];
 561                 boost::erase_first (n, X_("alsa_pcm:"));
 562
 563                 boost::shared_ptr<Bundle> c (new Bundle (n, true));
 564                 c->add_channel ("", DataType::MIDI);
 565                 c->set_port (0, outputs[DataType::MIDI][np]);
 566                 add_bundle (c);
 567         }
 568
 569         BootMessage (_("Setup signal flow and plugins"));
 570
 571         /* Reset all panners */
 572
 573         Delivery::reset_panners ();
 574
 575         /* this will cause the CPM to instantiate any protocols that are in use
 576          * (or mandatory), which will pass it this Session, and then call
 577          * set_state() on each instantiated protocol to match stored state.
 578          */
 579
 580         ControlProtocolManager::instance().set_session (this);
 581
 582         /* This must be done after the ControlProtocolManager set_session above,
 583            as it will set states for ports which the ControlProtocolManager creates.
 584         */
 585
 586         MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
 587
 588         /* And this must be done after the MIDI::Manager::set_port_states as
 589          * it will try to make connections whose details are loaded by set_port_states.
 590          */
 591
 592         hookup_io ();
 593
 594         /* Let control protocols know that we are now all connected, so they
 595          * could start talking to surfaces if they want to.
 596          */
 597
 598         ControlProtocolManager::instance().midi_connectivity_established ();
 599
 600         if (_is_new && !no_auto_connect()) {
 601                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
 602                 auto_connect_master_bus ();
 603         }
 604
 605         _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
 606
 607         /* update latencies */
 608
 609         initialize_latencies ();
 610
 611         /* hook us up to the engine */
 612
 613         BootMessage (_("Connect to engine"));
 614         _engine.set_session (this);
 615         _engine.reset_timebase ();
 616 }
 617
 618 void
 619 Session::auto_connect_master_bus ()
 620 {
 621         if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
 622                 return;
 623         }
 624
 625         /* if requested auto-connect the outputs to the first N physical ports.
 626          */
 627
 628         uint32_t limit = _master_out->n_outputs().n_total();
 629         vector<string> outputs[DataType::num_types];
 630
 631         for (uint32_t i = 0; i < DataType::num_types; ++i) {
 632                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
 633         }
 634
 635         for (uint32_t n = 0; n < limit; ++n) {
 636                 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
 637                 string connect_to;
 638                 if (outputs[p->type()].size() > n) {
 639                         connect_to = outputs[p->type()][n];
 640                 }
 641
 642                 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
 643                         if (_master_out->output()->connect (p, connect_to, this)) {
 644                                 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
 645                                       << endmsg;
 646                                 break;
 647                         }
 648                 }
 649         }
 650 }
 651
 652 void
 653 Session::remove_monitor_section ()
 654 {
 655         if (!_monitor_out) {
 656                 return;
 657         }
 658
 659         /* force reversion to Solo-In-Place */
 660         Config->set_solo_control_is_listen_control (false);
 661
 662         {
 663                 /* Hold process lock while doing this so that we don't hear bits and
 664                  * pieces of audio as we work on each route.
 665                  */
 666
 667                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 668
 669                 /* Connect tracks to monitor section. Note that in an
 670                    existing session, the internal sends will already exist, but we want the
 671                    routes to notice that they connect to the control out specifically.
 672                 */
 673
 674
 675                 boost::shared_ptr<RouteList> r = routes.reader ();
 676                 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
 677
 678                 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
 679
 680                         if ((*x)->is_monitor()) {
 681                                 /* relax */
 682                         } else if ((*x)->is_master()) {
 683                                 /* relax */
 684                         } else {
 685                                 (*x)->remove_aux_or_listen (_monitor_out);
 686                         }
 687                 }
 688         }
 689
 690         remove_route (_monitor_out);
 691         auto_connect_master_bus ();
 692 }
 693
 694 void
 695 Session::add_monitor_section ()
 696 {
 697         RouteList rl;
 698
 699         if (_monitor_out || !_master_out) {
 700                 return;
 701         }
 702
 703         boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
 704
 705         if (r->init ()) {
 706                 return;
 707         }
 708
 709 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
 710         // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
 711 #endif
 712         {
 713                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 714                 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
 715                 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
 716         }
 717
 718         rl.push_back (r);
 719         add_routes (rl, false, false, false);
 720
 721         assert (_monitor_out);
 722
 723         /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
 724            are undefined, at best.
 725         */
 726
 727         uint32_t limit = _monitor_out->n_inputs().n_audio();
 728
 729         if (_master_out) {
 730
 731                 /* connect the inputs to the master bus outputs. this
 732                  * represents a separate data feed from the internal sends from
 733                  * each route. as of jan 2011, it allows the monitor section to
 734                  * conditionally ignore either the internal sends or the normal
 735                  * input feed, but we should really find a better way to do
 736                  * this, i think.
 737                  */
 738
 739                 _master_out->output()->disconnect (this);
 740
 741                 for (uint32_t n = 0; n < limit; ++n) {
 742                         boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
 743                         boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
 744
 745                         if (o) {
 746                                 string connect_to = o->name();
 747                                 if (_monitor_out->input()->connect (p, connect_to, this)) {
 748                                         error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
 749                                               << endmsg;
 750                                         break;
 751                                 }
 752                         }
 753                 }
 754         }
 755
 756         /* if monitor section is not connected, connect it to physical outs
 757          */
 758
 759         if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
 760
 761                 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
 762
 763                         boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
 764
 765                         if (b) {
 766                                 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
 767                         } else {
 768                                 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
 769                                                            Config->get_monitor_bus_preferred_bundle())
 770                                         << endmsg;
 771                         }
 772
 773                 } else {
 774
 775                         /* Monitor bus is audio only */
 776
 777                         uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
 778                         uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
 779                         vector<string> outputs[DataType::num_types];
 780
 781                         for (uint32_t i = 0; i < DataType::num_types; ++i) {
 782                                 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
 783                         }
 784
 785
 786                         if (mod != 0) {
 787
 788                                 for (uint32_t n = 0; n < limit; ++n) {
 789
 790                                         boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
 791                                         string connect_to;
 792                                         if (outputs[DataType::AUDIO].size() > (n % mod)) {
 793                                                 connect_to = outputs[DataType::AUDIO][n % mod];
 794                                         }
 795
 796                                         if (!connect_to.empty()) {
 797                                                 if (_monitor_out->output()->connect (p, connect_to, this)) {
 798                                                         error << string_compose (
 799                                                                 _("cannot connect control output %1 to %2"),
 800                                                                 n, connect_to)
 801                                                               << endmsg;
 802                                                         break;
 803                                                 }
 804                                         }
 805                                 }
 806                         }
 807                 }
 808         }
 809
 810         /* Hold process lock while doing this so that we don't hear bits and
 811          * pieces of audio as we work on each route.
 812          */
 813
 814         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 815
 816         /* Connect tracks to monitor section. Note that in an
 817            existing session, the internal sends will already exist, but we want the
 818            routes to notice that they connect to the control out specifically.
 819         */
 820
 821
 822         boost::shared_ptr<RouteList> rls = routes.reader ();
 823
 824         PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
 825
 826         for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
 827
 828                 if ((*x)->is_monitor()) {
 829                         /* relax */
 830                 } else if ((*x)->is_master()) {
 831                         /* relax */
 832                 } else {
 833                         (*x)->enable_monitor_send ();
 834                 }
 835         }
 836 }
 837
 838 void
 839 Session::hookup_io ()
 840 {
 841         /* stop graph reordering notifications from
 842            causing resorts, etc.
 843         */
 844
 845         _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
 846
 847         if (!auditioner) {
 848
 849                 /* we delay creating the auditioner till now because
 850                    it makes its own connections to ports.
 851                 */
 852
 853                 try {
 854                         boost::shared_ptr<Auditioner> a (new Auditioner (*this));
 855                         if (a->init()) {
 856                                 throw failed_constructor ();
 857                         }
 858                         a->use_new_diskstream ();
 859                         auditioner = a;
 860                 }
 861
 862                 catch (failed_constructor& err) {
 863                         warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
 864                 }
 865         }
 866
 867         /* load bundles, which we may have postponed earlier on */
 868         if (_bundle_xml_node) {
 869                 load_bundles (*_bundle_xml_node);
 870                 delete _bundle_xml_node;
 871         }
 872
 873         /* Tell all IO objects to connect themselves together */
 874
 875         IO::enable_connecting ();
 876         MIDI::JackMIDIPort::MakeConnections ();
 877
 878         /* Anyone who cares about input state, wake up and do something */
 879
 880         IOConnectionsComplete (); /* EMIT SIGNAL */
 881
 882         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
 883
 884         /* now handle the whole enchilada as if it was one
 885            graph reorder event.
 886         */
 887
 888         graph_reordered ();
 889
 890         /* update the full solo state, which can't be
 891            correctly determined on a per-route basis, but
 892            needs the global overview that only the session
 893            has.
 894         */
 895
 896         update_route_solo_state ();
 897 }
 898
 899 void
 900 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
 901 {
 902         boost::shared_ptr<Track> track = wp.lock ();
 903         if (!track) {
 904                 return;
 905         }
 906
 907         boost::shared_ptr<Playlist> playlist;
 908
 909         if ((playlist = track->playlist()) != 0) {
 910                 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
 911                 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
 912                 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
 913         }
 914 }
 915
 916 bool
 917 Session::record_enabling_legal () const
 918 {
 919         /* this used to be in here, but survey says.... we don't need to restrict it */
 920         // if (record_status() == Recording) {
 921         //      return false;
 922         // }
 923
 924         if (Config->get_all_safe()) {
 925                 return false;
 926         }
 927         return true;
 928 }
 929
 930 void
 931 Session::set_track_monitor_input_status (bool yn)
 932 {
 933         boost::shared_ptr<RouteList> rl = routes.reader ();
 934         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 935                 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
 936                 if (tr && tr->record_enabled ()) {
 937                         //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
 938                         tr->request_jack_monitors_input (yn);
 939                 }
 940         }
 941 }
 942
 943 void
 944 Session::auto_punch_start_changed (Location* location)
 945 {
 946         replace_event (SessionEvent::PunchIn, location->start());
 947
 948         if (get_record_enabled() && config.get_punch_in()) {
 949                 /* capture start has been changed, so save new pending state */
 950                 save_state ("", true);
 951         }
 952 }
 953
 954 void
 955 Session::auto_punch_end_changed (Location* location)
 956 {
 957         framepos_t when_to_stop = location->end();
 958         // when_to_stop += _worst_output_latency + _worst_input_latency;
 959         replace_event (SessionEvent::PunchOut, when_to_stop);
 960 }
 961
 962 void
 963 Session::auto_punch_changed (Location* location)
 964 {
 965         framepos_t when_to_stop = location->end();
 966
 967         replace_event (SessionEvent::PunchIn, location->start());
 968         //when_to_stop += _worst_output_latency + _worst_input_latency;
 969         replace_event (SessionEvent::PunchOut, when_to_stop);
 970 }
 971
 972 /** @param loc A loop location.
 973  *  @param pos Filled in with the start time of the required fade-out (in session frames).
 974  *  @param length Filled in with the length of the required fade-out.
 975  */
 976 void
 977 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
 978 {
 979         pos = max (loc->start(), loc->end() - 64);
 980         length = loc->end() - pos;
 981 }
 982
 983 void
 984 Session::auto_loop_changed (Location* location)
 985 {
 986         replace_event (SessionEvent::AutoLoop, location->end(), location->start());
 987         framepos_t dcp;
 988         framecnt_t dcl;
 989         auto_loop_declick_range (location, dcp, dcl);
 990         replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
 991
 992         if (transport_rolling() && play_loop) {
 993
 994
 995                 // if (_transport_frame > location->end()) {
 996
 997                 if (_transport_frame < location->start() || _transport_frame > location->end()) {
 998                         // relocate to beginning of loop
 999                         clear_events (SessionEvent::LocateRoll);
1000
1001                         request_locate (location->start(), true);
1002
1003                 }
1004                 else if (Config->get_seamless_loop() && !loop_changing) {
1005
1006                         // schedule a locate-roll to refill the diskstreams at the
1007                         // previous loop end
1008                         loop_changing = true;
1009
1010                         if (location->end() > last_loopend) {
1011                                 clear_events (SessionEvent::LocateRoll);
1012                                 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1013                                 queue_event (ev);
1014                         }
1015
1016                 }
1017         }
1018
1019         last_loopend = location->end();
1020 }
1021
1022 void
1023 Session::set_auto_punch_location (Location* location)
1024 {
1025         Location* existing;
1026
1027         if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1028                 punch_connections.drop_connections();
1029                 existing->set_auto_punch (false, this);
1030                 remove_event (existing->start(), SessionEvent::PunchIn);
1031                 clear_events (SessionEvent::PunchOut);
1032                 auto_punch_location_changed (0);
1033         }
1034
1035         set_dirty();
1036
1037         if (location == 0) {
1038                 return;
1039         }
1040
1041         if (location->end() <= location->start()) {
1042                 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1043                 return;
1044         }
1045
1046         punch_connections.drop_connections ();
1047
1048         location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
1049         location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
1050         location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
1051
1052         location->set_auto_punch (true, this);
1053
1054         auto_punch_changed (location);
1055
1056         auto_punch_location_changed (location);
1057 }
1058
1059 void
1060 Session::set_auto_loop_location (Location* location)
1061 {
1062         Location* existing;
1063
1064         if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1065                 loop_connections.drop_connections ();
1066                 existing->set_auto_loop (false, this);
1067                 remove_event (existing->end(), SessionEvent::AutoLoop);
1068                 framepos_t dcp;
1069                 framecnt_t dcl;
1070                 auto_loop_declick_range (existing, dcp, dcl);
1071                 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1072                 auto_loop_location_changed (0);
1073         }
1074
1075         set_dirty();
1076
1077         if (location == 0) {
1078                 return;
1079         }
1080
1081         if (location->end() <= location->start()) {
1082                 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1083                 return;
1084         }
1085
1086         last_loopend = location->end();
1087
1088         loop_connections.drop_connections ();
1089
1090         location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1091         location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1092         location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
1093
1094         location->set_auto_loop (true, this);
1095
1096         /* take care of our stuff first */
1097
1098         auto_loop_changed (location);
1099
1100         /* now tell everyone else */
1101
1102         auto_loop_location_changed (location);
1103 }
1104
1105 void
1106 Session::locations_added (Location *)
1107 {
1108         set_dirty ();
1109 }
1110
1111 void
1112 Session::locations_changed ()
1113 {
1114         _locations->apply (*this, &Session::handle_locations_changed);
1115 }
1116
1117 void
1118 Session::handle_locations_changed (Locations::LocationList& locations)
1119 {
1120         Locations::LocationList::iterator i;
1121         Location* location;
1122         bool set_loop = false;
1123         bool set_punch = false;
1124
1125         for (i = locations.begin(); i != locations.end(); ++i) {
1126
1127                 location =* i;
1128
1129                 if (location->is_auto_punch()) {
1130                         set_auto_punch_location (location);
1131                         set_punch = true;
1132                 }
1133                 if (location->is_auto_loop()) {
1134                         set_auto_loop_location (location);
1135                         set_loop = true;
1136                 }
1137
1138                 if (location->is_session_range()) {
1139                         _session_range_location = location;
1140                 }
1141         }
1142
1143         if (!set_loop) {
1144                 set_auto_loop_location (0);
1145         }
1146         if (!set_punch) {
1147                 set_auto_punch_location (0);
1148         }
1149
1150         set_dirty();
1151 }
1152
1153 void
1154 Session::enable_record ()
1155 {
1156         if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1157                 /* no recording at anything except normal speed */
1158                 return;
1159         }
1160
1161         while (1) {
1162                 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1163
1164                 if (rs == Recording) {
1165                         break;
1166                 }
1167
1168                 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1169
1170                         _last_record_location = _transport_frame;
1171                         MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1172
1173                         if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1174                                 set_track_monitor_input_status (true);
1175                         }
1176
1177                         RecordStateChanged ();
1178                         break;
1179                 }
1180         }
1181 }
1182
1183 void
1184 Session::disable_record (bool rt_context, bool force)
1185 {
1186         RecordState rs;
1187
1188         if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1189
1190                 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1191                         g_atomic_int_set (&_record_status, Disabled);
1192                         MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1193                 } else {
1194                         if (rs == Recording) {
1195                                 g_atomic_int_set (&_record_status, Enabled);
1196                         }
1197                 }
1198
1199                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1200                         set_track_monitor_input_status (false);
1201                 }
1202
1203                 RecordStateChanged (); /* emit signal */
1204
1205                 if (!rt_context) {
1206                         remove_pending_capture_state ();
1207                 }
1208         }
1209 }
1210
1211 void
1212 Session::step_back_from_record ()
1213 {
1214         if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1215
1216                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1217                         set_track_monitor_input_status (false);
1218                 }
1219
1220                 RecordStateChanged (); /* emit signal */
1221         }
1222 }
1223
1224 void
1225 Session::maybe_enable_record ()
1226 {
1227         if (_step_editors > 0) {
1228                 return;
1229         }
1230
1231         g_atomic_int_set (&_record_status, Enabled);
1232
1233         /* This function is currently called from somewhere other than an RT thread.
1234            This save_state() call therefore doesn't impact anything.  Doing it here
1235            means that we save pending state of which sources the next record will use,
1236            which gives us some chance of recovering from a crash during the record.
1237         */
1238
1239         save_state ("", true);
1240
1241         if (_transport_speed) {
1242                 if (!config.get_punch_in()) {
1243                         enable_record ();
1244                 }
1245         } else {
1246                 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1247                 RecordStateChanged (); /* EMIT SIGNAL */
1248         }
1249
1250         set_dirty();
1251 }
1252
1253 framepos_t
1254 Session::audible_frame () const
1255 {
1256         framepos_t ret;
1257         framepos_t tf;
1258         framecnt_t offset;
1259
1260         /* the first of these two possible settings for "offset"
1261            mean that the audible frame is stationary until
1262            audio emerges from the latency compensation
1263            "pseudo-pipeline".
1264
1265            the second means that the audible frame is stationary
1266            until audio would emerge from a physical port
1267            in the absence of any plugin latency compensation
1268         */
1269
1270         offset = worst_playback_latency ();
1271
1272         if (offset > current_block_size) {
1273                 offset -= current_block_size;
1274         } else {
1275                 /* XXX is this correct? if we have no external
1276                    physical connections and everything is internal
1277                    then surely this is zero? still, how
1278                    likely is that anyway?
1279                 */
1280                 offset = current_block_size;
1281         }
1282
1283         if (synced_to_jack()) {
1284                 tf = _engine.transport_frame();
1285         } else {
1286                 tf = _transport_frame;
1287         }
1288
1289         ret = tf;
1290
1291         if (!non_realtime_work_pending()) {
1292
1293                 /* MOVING */
1294
1295                 /* Check to see if we have passed the first guaranteed
1296                    audible frame past our last start position. if not,
1297                    return that last start point because in terms
1298                    of audible frames, we have not moved yet.
1299
1300                    `Start position' in this context means the time we last
1301                    either started, located, or changed transport direction.
1302                 */
1303
1304                 if (_transport_speed > 0.0f) {
1305
1306                         if (!play_loop || !have_looped) {
1307                                 if (tf < _last_roll_or_reversal_location + offset) {
1308                                         return _last_roll_or_reversal_location;
1309                                 }
1310                         }
1311
1312
1313                         /* forwards */
1314                         ret -= offset;
1315
1316                 } else if (_transport_speed < 0.0f) {
1317
1318                         /* XXX wot? no backward looping? */
1319
1320                         if (tf > _last_roll_or_reversal_location - offset) {
1321                                 return _last_roll_or_reversal_location;
1322                         } else {
1323                                 /* backwards */
1324                                 ret += offset;
1325                         }
1326                 }
1327         }
1328
1329         return ret;
1330 }
1331
1332 void
1333 Session::set_frame_rate (framecnt_t frames_per_second)
1334 {
1335         /** \fn void Session::set_frame_size(framecnt_t)
1336                 the AudioEngine object that calls this guarantees
1337                 that it will not be called while we are also in
1338                 ::process(). Its fine to do things that block
1339                 here.
1340         */
1341
1342         _base_frame_rate = frames_per_second;
1343
1344         sync_time_vars();
1345
1346         clear_clicks ();
1347
1348         // XXX we need some equivalent to this, somehow
1349         // SndFileSource::setup_standard_crossfades (frames_per_second);
1350
1351         set_dirty();
1352
1353         /* XXX need to reset/reinstantiate all LADSPA plugins */
1354 }
1355
1356 void
1357 Session::set_block_size (pframes_t nframes)
1358 {
1359         /* the AudioEngine guarantees
1360            that it will not be called while we are also in
1361            ::process(). It is therefore fine to do things that block
1362            here.
1363         */
1364
1365         {
1366                 current_block_size = nframes;
1367
1368                 ensure_buffers ();
1369
1370                 boost::shared_ptr<RouteList> r = routes.reader ();
1371
1372                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1373                         (*i)->set_block_size (nframes);
1374                 }
1375
1376                 boost::shared_ptr<RouteList> rl = routes.reader ();
1377                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1378                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1379                         if (tr) {
1380                                 tr->set_block_size (nframes);
1381                         }
1382                 }
1383
1384                 set_worst_io_latencies ();
1385         }
1386 }
1387
1388
1389 static void
1390 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1391 {
1392         boost::shared_ptr<Route> r2;
1393
1394         if (r1->feeds (rbase) && rbase->feeds (r1)) {
1395                 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1396                 return;
1397         }
1398
1399         /* make a copy of the existing list of routes that feed r1 */
1400
1401         Route::FedBy existing (r1->fed_by());
1402
1403         /* for each route that feeds r1, recurse, marking it as feeding
1404            rbase as well.
1405         */
1406
1407         for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1408                 if (!(r2 = i->r.lock ())) {
1409                         /* (*i) went away, ignore it */
1410                         continue;
1411                 }
1412
1413                 /* r2 is a route that feeds r1 which somehow feeds base. mark
1414                    base as being fed by r2
1415                 */
1416
1417                 rbase->add_fed_by (r2, i->sends_only);
1418
1419                 if (r2 != rbase) {
1420
1421                         /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1422                            stop here.
1423                         */
1424
1425                         if (r1->feeds (r2) && r2->feeds (r1)) {
1426                                 continue;
1427                         }
1428
1429                         /* now recurse, so that we can mark base as being fed by
1430                            all routes that feed r2
1431                         */
1432
1433                         trace_terminal (r2, rbase);
1434                 }
1435
1436         }
1437 }
1438
1439 void
1440 Session::resort_routes ()
1441 {
1442         /* don't do anything here with signals emitted
1443            by Routes during initial setup or while we
1444            are being destroyed.
1445         */
1446
1447         if (_state_of_the_state & (InitialConnecting | Deletion)) {
1448                 return;
1449         }
1450
1451         {
1452                 RCUWriter<RouteList> writer (routes);
1453                 boost::shared_ptr<RouteList> r = writer.get_copy ();
1454                 resort_routes_using (r);
1455                 /* writer goes out of scope and forces update */
1456         }
1457
1458 #ifndef NDEBUG
1459         boost::shared_ptr<RouteList> rl = routes.reader ();
1460         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1461                 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
1462
1463                 const Route::FedBy& fb ((*i)->fed_by());
1464
1465                 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
1466                         boost::shared_ptr<Route> sf = f->r.lock();
1467                         if (sf) {
1468                                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1469                         }
1470                 }
1471         }
1472 #endif
1473
1474 }
1475
1476 /** This is called whenever we need to rebuild the graph of how we will process
1477  *  routes.
1478  *  @param r List of routes, in any order.
1479  */
1480
1481 void
1482 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
1483 {
1484         /* We are going to build a directed graph of our routes;
1485            this is where the edges of that graph are put.
1486         */
1487
1488         GraphEdges edges;
1489
1490         /* Go through all routes doing two things:
1491          *
1492          * 1. Collect the edges of the route graph.  Each of these edges
1493          *    is a pair of routes, one of which directly feeds the other
1494          *    either by a JACK connection or by an internal send.
1495          *
1496          * 2. Begin the process of making routes aware of which other
1497          *    routes directly or indirectly feed them.  This information
1498          *    is used by the solo code.
1499          */
1500
1501         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1502
1503                 /* Clear out the route's list of direct or indirect feeds */
1504                 (*i)->clear_fed_by ();
1505
1506                 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
1507
1508                         bool via_sends_only;
1509
1510                         /* See if this *j feeds *i according to the current state of the JACK
1511                            connections and internal sends.
1512                         */
1513                         if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
1514                                 /* add the edge to the graph (part #1) */
1515                                 edges.add (*j, *i, via_sends_only);
1516                                 /* tell the route (for part #2) */
1517                                 (*i)->add_fed_by (*j, via_sends_only);
1518                         }
1519                 }
1520         }
1521
1522         /* Attempt a topological sort of the route graph */
1523         boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
1524
1525         if (sorted_routes) {
1526                 /* We got a satisfactory topological sort, so there is no feedback;
1527                    use this new graph.
1528
1529                    Note: the process graph rechain does not require a
1530                    topologically-sorted list, but hey ho.
1531                 */
1532                 if (_process_graph) {
1533                         _process_graph->rechain (sorted_routes, edges);
1534                 }
1535
1536                 _current_route_graph = edges;
1537
1538                 /* Complete the building of the routes' lists of what directly
1539                    or indirectly feeds them.
1540                 */
1541                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1542                         trace_terminal (*i, *i);
1543                 }
1544
1545                 *r = *sorted_routes;
1546
1547 #ifndef NDEBUG
1548                 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
1549                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1550                         DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
1551                                                                    (*i)->name(), (*i)->order_key (MixerSort)));
1552                 }
1553 #endif
1554
1555                 SuccessfulGraphSort (); /* EMIT SIGNAL */
1556
1557         } else {
1558                 /* The topological sort failed, so we have a problem.  Tell everyone
1559                    and stick to the old graph; this will continue to be processed, so
1560                    until the feedback is fixed, what is played back will not quite
1561                    reflect what is actually connected.  Note also that we do not
1562                    do trace_terminal here, as it would fail due to an endless recursion,
1563                    so the solo code will think that everything is still connected
1564                    as it was before.
1565                 */
1566
1567                 FeedbackDetected (); /* EMIT SIGNAL */
1568         }
1569
1570 }
1571
1572 /** Find a route name starting with \a base, maybe followed by the
1573  *  lowest \a id.  \a id will always be added if \a definitely_add_number
1574  *  is true on entry; otherwise it will only be added if required
1575  *  to make the name unique.
1576  *
1577  *  Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1578  *  The available route name with the lowest ID will be used, and \a id
1579  *  will be set to the ID.
1580  *
1581  *  \return false if a route name could not be found, and \a track_name
1582  *  and \a id do not reflect a free route name.
1583  */
1584 bool
1585 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
1586 {
1587         if (!definitely_add_number && route_by_name (base) == 0) {
1588                 /* juse use the base */
1589                 snprintf (name, name_len, "%s", base.c_str());
1590                 return true;
1591         }
1592
1593         do {
1594                 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
1595
1596                 if (route_by_name (name) == 0) {
1597                         return true;
1598                 }
1599
1600                 ++id;
1601
1602         } while (id < (UINT_MAX-1));
1603
1604         return false;
1605 }
1606
1607 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
1608 void
1609 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
1610 {
1611         in  = ChanCount::ZERO;
1612         out = ChanCount::ZERO;
1613
1614         boost::shared_ptr<RouteList> r = routes.reader ();
1615
1616         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1617                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1618                 if (tr && !tr->is_hidden()) {
1619                         in  += tr->n_inputs();
1620                         out += tr->n_outputs();
1621                 }
1622         }
1623 }
1624
1625 /** Caller must not hold process lock
1626  *  @param name_template string to use for the start of the name, or "" to use "MIDI".
1627  *  @param instrument plugin info for the instrument to insert pre-fader, if any
1628  */
1629 list<boost::shared_ptr<MidiTrack> >
1630 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
1631                          TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
1632 {
1633         char track_name[32];
1634         uint32_t track_id = 0;
1635         string port;
1636         RouteList new_routes;
1637         list<boost::shared_ptr<MidiTrack> > ret;
1638
1639         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
1640
1641         while (how_many) {
1642                 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1643                         error << "cannot find name for new midi track" << endmsg;
1644                         goto failed;
1645                 }
1646
1647                 boost::shared_ptr<MidiTrack> track;
1648
1649                 try {
1650                         track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1651
1652                         if (track->init ()) {
1653                                 goto failed;
1654                         }
1655
1656                         track->use_new_diskstream();
1657
1658 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1659                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1660 #endif
1661                         {
1662                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1663                                 if (track->input()->ensure_io (input, false, this)) {
1664                                         error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
1665                                         goto failed;
1666                                 }
1667
1668                                 if (track->output()->ensure_io (output, false, this)) {
1669                                         error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
1670                                         goto failed;
1671                                 }
1672                         }
1673
1674                         track->non_realtime_input_change();
1675
1676                         if (route_group) {
1677                                 route_group->add (track);
1678                         }
1679
1680                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1681
1682                         if (Config->get_remote_model() == UserOrdered) {
1683                                 track->set_remote_control_id (next_control_id());
1684                         }
1685
1686                         new_routes.push_back (track);
1687                         ret.push_back (track);
1688                 }
1689
1690                 catch (failed_constructor &err) {
1691                         error << _("Session: could not create new midi track.") << endmsg;
1692                         goto failed;
1693                 }
1694
1695                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1696
1697                         error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1698                         goto failed;
1699                 }
1700
1701                 --how_many;
1702         }
1703
1704   failed:
1705         if (!new_routes.empty()) {
1706                 add_routes (new_routes, true, true, true);
1707
1708                 if (instrument) {
1709                         for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
1710                                 PluginPtr plugin = instrument->load (*this);
1711                                 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
1712                                 (*r)->add_processor (p, PreFader);
1713
1714                         }
1715                 }
1716         }
1717
1718         return ret;
1719 }
1720
1721 void
1722 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
1723 {
1724         boost::shared_ptr<Route> midi_track (wmt.lock());
1725
1726         if (!midi_track) {
1727                 return;
1728         }
1729
1730         if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
1731
1732                 if (change.after.n_audio() <= change.before.n_audio()) {
1733                         return;
1734                 }
1735
1736                 /* new audio ports: make sure the audio goes somewhere useful,
1737                    unless the user has no-auto-connect selected.
1738
1739                    The existing ChanCounts don't matter for this call as they are only
1740                    to do with matching input and output indices, and we are only changing
1741                    outputs here.
1742                 */
1743
1744                 ChanCount dummy;
1745
1746                 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
1747         }
1748 }
1749
1750 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
1751  *  @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
1752  *  @param output_start As \a input_start, but for outputs.
1753  */
1754 void
1755 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
1756                              bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
1757 {
1758         if (!IO::connecting_legal) {
1759                 return;
1760         }
1761
1762         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1763
1764         if (with_lock) {
1765                 lm.acquire ();
1766         }
1767
1768         /* If both inputs and outputs are auto-connected to physical ports,
1769            use the max of input and output offsets to ensure auto-connected
1770            port numbers always match up (e.g. the first audio input and the
1771            first audio output of the route will have the same physical
1772            port number).  Otherwise just use the lowest input or output
1773            offset possible.
1774         */
1775
1776         DEBUG_TRACE (DEBUG::Graph,
1777                      string_compose("Auto-connect: existing in = %1 out = %2\n",
1778                                     existing_inputs, existing_outputs));
1779
1780         const bool in_out_physical =
1781                 (Config->get_input_auto_connect() & AutoConnectPhysical)
1782                 && (Config->get_output_auto_connect() & AutoConnectPhysical)
1783                 && connect_inputs;
1784
1785         const ChanCount in_offset = in_out_physical
1786                 ? ChanCount::max(existing_inputs, existing_outputs)
1787                 : existing_inputs;
1788
1789         const ChanCount out_offset = in_out_physical
1790                 ? ChanCount::max(existing_inputs, existing_outputs)
1791                 : existing_outputs;
1792
1793         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1794                 vector<string> physinputs;
1795                 vector<string> physoutputs;
1796
1797                 _engine.get_physical_outputs (*t, physoutputs);
1798                 _engine.get_physical_inputs (*t, physinputs);
1799
1800                 if (!physinputs.empty() && connect_inputs) {
1801                         uint32_t nphysical_in = physinputs.size();
1802
1803                         DEBUG_TRACE (DEBUG::Graph,
1804                                      string_compose("There are %1 physical inputs of type %2\n",
1805                                                     nphysical_in, *t));
1806
1807                         for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1808                                 string port;
1809
1810                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1811                                         DEBUG_TRACE (DEBUG::Graph,
1812                                                      string_compose("Get index %1 + %2 % %3 = %4\n",
1813                                                                     in_offset.get(*t), i, nphysical_in,
1814                                                                     (in_offset.get(*t) + i) % nphysical_in));
1815                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1816                                 }
1817
1818                                 DEBUG_TRACE (DEBUG::Graph,
1819                                              string_compose("Connect route %1 IN to %2\n",
1820                                                             route->name(), port));
1821
1822                                 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
1823                                         break;
1824                                 }
1825
1826                                 ChanCount one_added (*t, 1);
1827                                 existing_inputs += one_added;
1828                         }
1829                 }
1830
1831                 if (!physoutputs.empty()) {
1832                         uint32_t nphysical_out = physoutputs.size();
1833                         for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
1834                                 string port;
1835
1836                                 if ((*t) == DataType::MIDI || Config->get_output_auto_connect() & AutoConnectPhysical) {
1837                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1838                                 } else if ((*t) == DataType::AUDIO && Config->get_output_auto_connect() & AutoConnectMaster) {
1839                                         /* master bus is audio only */
1840                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1841                                                 port = _master_out->input()->ports().port(*t,
1842                                                                 i % _master_out->input()->n_ports().get(*t))->name();
1843                                         }
1844                                 }
1845
1846                                 DEBUG_TRACE (DEBUG::Graph,
1847                                              string_compose("Connect route %1 OUT to %2\n",
1848                                                             route->name(), port));
1849
1850                                 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
1851                                         break;
1852                                 }
1853
1854                                 ChanCount one_added (*t, 1);
1855                                 existing_outputs += one_added;
1856                         }
1857                 }
1858         }
1859 }
1860
1861 /** Caller must not hold process lock
1862  *  @param name_template string to use for the start of the name, or "" to use "Audio".
1863  */
1864 list< boost::shared_ptr<AudioTrack> >
1865 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
1866                           uint32_t how_many, string name_template)
1867 {
1868         char track_name[32];
1869         uint32_t track_id = 0;
1870         string port;
1871         RouteList new_routes;
1872         list<boost::shared_ptr<AudioTrack> > ret;
1873
1874         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Audio");
1875
1876         while (how_many) {
1877                 if (!find_route_name (name_template.empty() ? _("Audio") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
1878                         error << "cannot find name for new audio track" << endmsg;
1879                         goto failed;
1880                 }
1881
1882                 boost::shared_ptr<AudioTrack> track;
1883
1884                 try {
1885                         track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
1886
1887                         if (track->init ()) {
1888                                 goto failed;
1889                         }
1890
1891                         track->use_new_diskstream();
1892
1893 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1894                         // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
1895 #endif
1896                         {
1897                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1898
1899                                 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1900                                         error << string_compose (
1901                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
1902                                                 input_channels, output_channels)
1903                                               << endmsg;
1904                                         goto failed;
1905                                 }
1906
1907                                 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1908                                         error << string_compose (
1909                                                 _("cannot configure %1 in/%2 out configuration for new audio track"),
1910                                                 input_channels, output_channels)
1911                                               << endmsg;
1912                                         goto failed;
1913                                 }
1914                         }
1915
1916                         if (route_group) {
1917                                 route_group->add (track);
1918                         }
1919
1920                         track->non_realtime_input_change();
1921
1922                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1923                         if (Config->get_remote_model() == UserOrdered) {
1924                                 track->set_remote_control_id (next_control_id());
1925                         }
1926
1927                         new_routes.push_back (track);
1928                         ret.push_back (track);
1929                 }
1930
1931                 catch (failed_constructor &err) {
1932                         error << _("Session: could not create new audio track.") << endmsg;
1933                         goto failed;
1934                 }
1935
1936                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1937
1938                         error << pfe.what() << endmsg;
1939                         goto failed;
1940                 }
1941
1942                 --how_many;
1943         }
1944
1945   failed:
1946         if (!new_routes.empty()) {
1947                 add_routes (new_routes, true, true, true);
1948         }
1949
1950         return ret;
1951 }
1952
1953 /** Caller must not hold process lock.
1954  *  @param name_template string to use for the start of the name, or "" to use "Bus".
1955  */
1956 RouteList
1957 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
1958 {
1959         char bus_name[32];
1960         uint32_t bus_id = 0;
1961         string port;
1962         RouteList ret;
1963
1964         bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
1965
1966         while (how_many) {
1967                 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
1968                         error << "cannot find name for new audio bus" << endmsg;
1969                         goto failure;
1970                 }
1971
1972                 try {
1973                         boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
1974
1975                         if (bus->init ()) {
1976                                 goto failure;
1977                         }
1978
1979 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1980                         // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
1981 #endif
1982                         {
1983                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1984
1985                                 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1986                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1987                                                                  input_channels, output_channels)
1988                                               << endmsg;
1989                                         goto failure;
1990                                 }
1991
1992
1993                                 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1994                                         error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1995                                                                  input_channels, output_channels)
1996                                               << endmsg;
1997                                         goto failure;
1998                                 }
1999                         }
2000
2001                         if (route_group) {
2002                                 route_group->add (bus);
2003                         }
2004                         if (Config->get_remote_model() == UserOrdered) {
2005                                 bus->set_remote_control_id (next_control_id());
2006                         }
2007
2008                         bus->add_internal_return ();
2009
2010                         ret.push_back (bus);
2011
2012                         ARDOUR::GUIIdle ();
2013                 }
2014
2015
2016                 catch (failed_constructor &err) {
2017                         error << _("Session: could not create new audio route.") << endmsg;
2018                         goto failure;
2019                 }
2020
2021                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2022                         error << pfe.what() << endmsg;
2023                         goto failure;
2024                 }
2025
2026
2027                 --how_many;
2028         }
2029
2030   failure:
2031         if (!ret.empty()) {
2032                 add_routes (ret, false, true, true); // autoconnect outputs only
2033         }
2034
2035         return ret;
2036
2037 }
2038
2039 RouteList
2040 Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
2041 {
2042         RouteList ret;
2043         uint32_t control_id;
2044         XMLTree tree;
2045         uint32_t number = 0;
2046
2047         if (!tree.read (template_path.c_str())) {
2048                 return ret;
2049         }
2050
2051         XMLNode* node = tree.root();
2052
2053         IO::disable_connecting ();
2054
2055         control_id = next_control_id ();
2056
2057         while (how_many) {
2058
2059                 XMLNode node_copy (*node);
2060
2061                 /* Remove IDs of everything so that new ones are used */
2062                 node_copy.remove_property_recursively (X_("id"));
2063
2064                 try {
2065                         string const route_name = node_copy.property(X_("name"))->value ();
2066
2067                         /* generate a new name by adding a number to the end of the template name */
2068                         char name[32];
2069                         if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2070                                 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2071                                 /*NOTREACHED*/
2072                         }
2073
2074                         /* set this name in the XML description that we are about to use */
2075                         Route::set_name_in_state (node_copy, name);
2076
2077                         /* trim bitslots from listen sends so that new ones are used */
2078                         XMLNodeList children = node_copy.children ();
2079                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2080                                 if ((*i)->name() == X_("Processor")) {
2081                                         XMLProperty* role = (*i)->property (X_("role"));
2082                                         if (role && role->value() == X_("Listen")) {
2083                                                 (*i)->remove_property (X_("bitslot"));
2084                                         }
2085                                 }
2086                         }
2087
2088                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2089
2090                         if (route == 0) {
2091                                 error << _("Session: cannot create track/bus from template description") << endmsg;
2092                                 goto out;
2093                         }
2094
2095                         if (boost::dynamic_pointer_cast<Track>(route)) {
2096                                 /* force input/output change signals so that the new diskstream
2097                                    picks up the configuration of the route. During session
2098                                    loading this normally happens in a different way.
2099                                 */
2100
2101                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2102
2103                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2104                                 change.after = route->input()->n_ports();
2105                                 route->input()->changed (change, this);
2106                                 change.after = route->output()->n_ports();
2107                                 route->output()->changed (change, this);
2108                         }
2109
2110                         route->set_remote_control_id (control_id);
2111                         ++control_id;
2112
2113                         ret.push_back (route);
2114                 }
2115
2116                 catch (failed_constructor &err) {
2117                         error << _("Session: could not create new route from template") << endmsg;
2118                         goto out;
2119                 }
2120
2121                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2122                         error << pfe.what() << endmsg;
2123                         goto out;
2124                 }
2125
2126                 --how_many;
2127         }
2128
2129   out:
2130         if (!ret.empty()) {
2131                 add_routes (ret, true, true, true);
2132                 IO::enable_connecting ();
2133         }
2134
2135         return ret;
2136 }
2137
2138 void
2139 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2140 {
2141         try {
2142                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2143                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2144
2145         } catch (...) {
2146                 error << _("Adding new tracks/busses failed") << endmsg;
2147         }
2148
2149         graph_reordered ();
2150
2151         update_latency (true);
2152         update_latency (false);
2153
2154         set_dirty();
2155
2156         if (save) {
2157                 save_state (_current_snapshot_name);
2158         }
2159
2160         RouteAdded (new_routes); /* EMIT SIGNAL */
2161 }
2162
2163 void
2164 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2165 {
2166         ChanCount existing_inputs;
2167         ChanCount existing_outputs;
2168         uint32_t order = next_control_id();
2169
2170         count_existing_track_channels (existing_inputs, existing_outputs);
2171
2172         {
2173                 RCUWriter<RouteList> writer (routes);
2174                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2175                 r->insert (r->end(), new_routes.begin(), new_routes.end());
2176
2177                 /* if there is no control out and we're not in the middle of loading,
2178                    resort the graph here. if there is a control out, we will resort
2179                    toward the end of this method. if we are in the middle of loading,
2180                    we will resort when done.
2181                 */
2182
2183                 if (!_monitor_out && IO::connecting_legal) {
2184                         resort_routes_using (r);
2185                 }
2186         }
2187
2188         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2189
2190                 boost::weak_ptr<Route> wpr (*x);
2191                 boost::shared_ptr<Route> r (*x);
2192
2193                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2194                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2195                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2196                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2197                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2198                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2199
2200                 if (r->is_master()) {
2201                         _master_out = r;
2202                 }
2203
2204                 if (r->is_monitor()) {
2205                         _monitor_out = r;
2206                 }
2207
2208                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2209                 if (tr) {
2210                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2211                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2212                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2213
2214                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2215                         if (mt) {
2216                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2217                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2218                         }
2219                 }
2220
2221
2222                 if (input_auto_connect || output_auto_connect) {
2223                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2224                 }
2225
2226                 /* order keys are a GUI responsibility but we need to set up
2227                    reasonable defaults because they also affect the remote control
2228                    ID in most situations.
2229                 */
2230
2231                 if (!r->has_order_key (EditorSort)) {
2232                         if (r->is_hidden()) {
2233                                 /* use an arbitrarily high value */
2234                                 r->set_order_key (EditorSort, UINT_MAX);
2235                                 r->set_order_key (MixerSort, UINT_MAX);
2236                         } else {
2237                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2238                                 r->set_order_key (EditorSort, order);
2239                                 r->set_order_key (MixerSort, order);
2240                                 order++;
2241                         }
2242                 }
2243
2244                 ARDOUR::GUIIdle ();
2245         }
2246
2247         if (_monitor_out && IO::connecting_legal) {
2248                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2249
2250                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2251                         if ((*x)->is_monitor()) {
2252                                 /* relax */
2253                         } else if ((*x)->is_master()) {
2254                                         /* relax */
2255                         } else {
2256                                 (*x)->enable_monitor_send ();
2257                         }
2258                 }
2259         }
2260 }
2261
2262 void
2263 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2264 {
2265         boost::shared_ptr<RouteList> r = routes.reader ();
2266         boost::shared_ptr<Send> s;
2267
2268         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2269                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2270                         s->amp()->gain_control()->set_value (0.0);
2271                 }
2272         }
2273 }
2274
2275 void
2276 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2277 {
2278         boost::shared_ptr<RouteList> r = routes.reader ();
2279         boost::shared_ptr<Send> s;
2280
2281         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2282                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2283                         s->amp()->gain_control()->set_value (1.0);
2284                 }
2285         }
2286 }
2287
2288 void
2289 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2290 {
2291         boost::shared_ptr<RouteList> r = routes.reader ();
2292         boost::shared_ptr<Send> s;
2293
2294         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2295                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2296                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2297                 }
2298         }
2299 }
2300
2301 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2302 void
2303 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2304 {
2305         boost::shared_ptr<RouteList> r = routes.reader ();
2306         boost::shared_ptr<RouteList> t (new RouteList);
2307
2308         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2309                 /* no MIDI sends because there are no MIDI busses yet */
2310                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2311                         t->push_back (*i);
2312                 }
2313         }
2314
2315         add_internal_sends (dest, p, t);
2316 }
2317
2318 void
2319 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2320 {
2321         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2322                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2323         }
2324 }
2325
2326 void
2327 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2328 {
2329         add_internal_send (dest, sender->before_processor_for_index (index), sender);
2330 }
2331
2332 void
2333 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2334 {
2335         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2336                 return;
2337         }
2338
2339         if (!dest->internal_return()) {
2340                 dest->add_internal_return ();
2341         }
2342
2343         sender->add_aux_send (dest, before);
2344
2345         graph_reordered ();
2346 }
2347
2348 void
2349 Session::remove_route (boost::shared_ptr<Route> route)
2350 {
2351         if (route == _master_out) {
2352                 return;
2353         }
2354
2355         route->set_solo (false, this);
2356
2357         {
2358                 RCUWriter<RouteList> writer (routes);
2359                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2360
2361                 rs->remove (route);
2362
2363                 /* deleting the master out seems like a dumb
2364                    idea, but its more of a UI policy issue
2365                    than our concern.
2366                 */
2367
2368                 if (route == _master_out) {
2369                         _master_out = boost::shared_ptr<Route> ();
2370                 }
2371
2372                 if (route == _monitor_out) {
2373                         _monitor_out.reset ();
2374                 }
2375
2376                 /* writer goes out of scope, forces route list update */
2377         }
2378
2379         update_route_solo_state ();
2380
2381         // We need to disconnect the route's inputs and outputs
2382
2383         route->input()->disconnect (0);
2384         route->output()->disconnect (0);
2385
2386         /* if the route had internal sends sending to it, remove them */
2387         if (route->internal_return()) {
2388
2389                 boost::shared_ptr<RouteList> r = routes.reader ();
2390                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2391                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2392                         if (s) {
2393                                 (*i)->remove_processor (s);
2394                         }
2395                 }
2396         }
2397
2398         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2399         if (mt && mt->step_editing()) {
2400                 if (_step_editors > 0) {
2401                         _step_editors--;
2402                 }
2403         }
2404
2405         update_latency_compensation ();
2406         set_dirty();
2407
2408         /* Re-sort routes to remove the graph's current references to the one that is
2409          * going away, then flush old references out of the graph.
2410          */
2411
2412         resort_routes ();
2413         if (_process_graph) {
2414                 _process_graph->clear_other_chain ();
2415         }
2416
2417         /* get rid of it from the dead wood collection in the route list manager */
2418
2419         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2420
2421         routes.flush ();
2422
2423         /* try to cause everyone to drop their references */
2424
2425         route->drop_references ();
2426
2427         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2428
2429         /* save the new state of the world */
2430
2431         if (save_state (_current_snapshot_name)) {
2432                 save_history (_current_snapshot_name);
2433         }
2434 }
2435
2436 void
2437 Session::route_mute_changed (void* /*src*/)
2438 {
2439         set_dirty ();
2440 }
2441
2442 void
2443 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2444 {
2445         boost::shared_ptr<Route> route = wpr.lock();
2446         if (!route) {
2447                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2448                 return;
2449         }
2450
2451         if (route->listening_via_monitor ()) {
2452
2453                 if (Config->get_exclusive_solo()) {
2454                         /* new listen: disable all other listen */
2455                         boost::shared_ptr<RouteList> r = routes.reader ();
2456                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2457                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2458                                         continue;
2459                                 }
2460                                 (*i)->set_listen (false, this);
2461                         }
2462                 }
2463
2464                 _listen_cnt++;
2465
2466         } else if (_listen_cnt > 0) {
2467
2468                 _listen_cnt--;
2469         }
2470
2471         update_route_solo_state ();
2472 }
2473 void
2474 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2475 {
2476         boost::shared_ptr<Route> route = wpr.lock ();
2477
2478         if (!route) {
2479                 /* should not happen */
2480                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2481                 return;
2482         }
2483
2484         bool send_changed = false;
2485
2486         if (route->solo_isolated()) {
2487                 if (_solo_isolated_cnt == 0) {
2488                         send_changed = true;
2489                 }
2490                 _solo_isolated_cnt++;
2491         } else if (_solo_isolated_cnt > 0) {
2492                 _solo_isolated_cnt--;
2493                 if (_solo_isolated_cnt == 0) {
2494                         send_changed = true;
2495                 }
2496         }
2497
2498         if (send_changed) {
2499                 IsolatedChanged (); /* EMIT SIGNAL */
2500         }
2501 }
2502
2503 void
2504 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2505 {
2506         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2507
2508         if (!self_solo_change) {
2509                 // session doesn't care about changes to soloed-by-others
2510                 return;
2511         }
2512
2513         if (solo_update_disabled) {
2514                 // We know already
2515                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2516                 return;
2517         }
2518
2519         boost::shared_ptr<Route> route = wpr.lock ();
2520         assert (route);
2521
2522         boost::shared_ptr<RouteList> r = routes.reader ();
2523         int32_t delta;
2524
2525         if (route->self_soloed()) {
2526                 delta = 1;
2527         } else {
2528                 delta = -1;
2529         }
2530
2531         RouteGroup* rg = route->route_group ();
2532         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2533
2534         if (delta == 1 && Config->get_exclusive_solo()) {
2535
2536                 /* new solo: disable all other solos, but not the group if its solo-enabled */
2537
2538                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2539                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2540                             (leave_group_alone && ((*i)->route_group() == rg))) {
2541                                 continue;
2542                         }
2543                         (*i)->set_solo (false, this);
2544                 }
2545         }
2546
2547         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2548
2549         solo_update_disabled = true;
2550
2551         RouteList uninvolved;
2552
2553         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2554
2555         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2556                 bool via_sends_only;
2557                 bool in_signal_flow;
2558
2559                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden() ||
2560                     (leave_group_alone && ((*i)->route_group() == rg))) {
2561                         continue;
2562                 }
2563
2564                 in_signal_flow = false;
2565
2566                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2567
2568                 if ((*i)->feeds (route, &via_sends_only)) {
2569                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2570                         if (!via_sends_only) {
2571                                 if (!route->soloed_by_others_upstream()) {
2572                                         (*i)->mod_solo_by_others_downstream (delta);
2573                                 }
2574                         } else {
2575                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2576                         }
2577                         in_signal_flow = true;
2578                 } else {
2579                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2580                 }
2581
2582                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2583
2584                 if (route->feeds (*i, &via_sends_only)) {
2585                         /* propagate solo upstream only if routing other than
2586                            sends is involved, but do consider the other route
2587                            (*i) to be part of the signal flow even if only
2588                            sends are involved.
2589                         */
2590                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2591                                                                   route->name(),
2592                                                                   (*i)->name(),
2593                                                                   via_sends_only,
2594                                                                   route->soloed_by_others_downstream(),
2595                                                                   route->soloed_by_others_upstream()));
2596                         if (!via_sends_only) {
2597                                 if (!route->soloed_by_others_downstream()) {
2598                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2599                                         (*i)->mod_solo_by_others_upstream (delta);
2600                                 } else {
2601                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2602                                 }
2603                         } else {
2604                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2605                         }
2606                         in_signal_flow = true;
2607                 } else {
2608                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2609                 }
2610
2611                 if (!in_signal_flow) {
2612                         uninvolved.push_back (*i);
2613                 }
2614         }
2615
2616         solo_update_disabled = false;
2617         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2618
2619         update_route_solo_state (r);
2620
2621         /* now notify that the mute state of the routes not involved in the signal
2622            pathway of the just-solo-changed route may have altered.
2623         */
2624
2625         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2626                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2627                 (*i)->mute_changed (this);
2628         }
2629
2630         SoloChanged (); /* EMIT SIGNAL */
2631         set_dirty();
2632 }
2633
2634 void
2635 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2636 {
2637         /* now figure out if anything that matters is soloed (or is "listening")*/
2638
2639         bool something_soloed = false;
2640         uint32_t listeners = 0;
2641         uint32_t isolated = 0;
2642
2643         if (!r) {
2644                 r = routes.reader();
2645         }
2646
2647         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2648                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2649                         something_soloed = true;
2650                 }
2651
2652                 if (!(*i)->is_hidden() && (*i)->listening_via_monitor()) {
2653                         if (Config->get_solo_control_is_listen_control()) {
2654                                 listeners++;
2655                         } else {
2656                                 (*i)->set_listen (false, this);
2657                         }
2658                 }
2659
2660                 if ((*i)->solo_isolated()) {
2661                         isolated++;
2662                 }
2663         }
2664
2665         if (something_soloed != _non_soloed_outs_muted) {
2666                 _non_soloed_outs_muted = something_soloed;
2667                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2668         }
2669
2670         _listen_cnt = listeners;
2671
2672         if (isolated != _solo_isolated_cnt) {
2673                 _solo_isolated_cnt = isolated;
2674                 IsolatedChanged (); /* EMIT SIGNAL */
2675         }
2676
2677         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2678                                                   something_soloed, listeners, isolated));
2679 }
2680
2681 boost::shared_ptr<RouteList>
2682 Session::get_routes_with_internal_returns() const
2683 {
2684         boost::shared_ptr<RouteList> r = routes.reader ();
2685         boost::shared_ptr<RouteList> rl (new RouteList);
2686
2687         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2688                 if ((*i)->internal_return ()) {
2689                         rl->push_back (*i);
2690                 }
2691         }
2692         return rl;
2693 }
2694
2695 bool
2696 Session::io_name_is_legal (const std::string& name)
2697 {
2698         boost::shared_ptr<RouteList> r = routes.reader ();
2699
2700         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2701                 if ((*i)->name() == name) {
2702                         return false;
2703                 }
2704
2705                 if ((*i)->has_io_processor_named (name)) {
2706                         return false;
2707                 }
2708         }
2709
2710         return true;
2711 }
2712
2713 void
2714 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2715 {
2716         RouteList rl2;
2717         vector<string> connections;
2718
2719         /* if we are passed only a single route and we're not told to turn
2720          * others off, then just do the simple thing.
2721          */
2722
2723         if (flip_others == false && rl->size() == 1) {
2724                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2725                 if (mt) {
2726                         mt->set_input_active (onoff);
2727                         return;
2728                 }
2729         }
2730
2731         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2732
2733                 PortSet& ps ((*rt)->input()->ports());
2734
2735                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2736                         p->get_connections (connections);
2737                 }
2738
2739                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2740                         routes_using_input_from (*s, rl2);
2741                 }
2742
2743                 /* scan all relevant routes to see if others are on or off */
2744
2745                 bool others_are_already_on = false;
2746
2747                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2748
2749                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2750
2751                         if (!mt) {
2752                                 continue;
2753                         }
2754
2755                         if ((*r) != (*rt)) {
2756                                 if (mt->input_active()) {
2757                                         others_are_already_on = true;
2758                                 }
2759                         } else {
2760                                 /* this one needs changing */
2761                                 mt->set_input_active (onoff);
2762                         }
2763                 }
2764
2765                 if (flip_others) {
2766
2767                         /* globally reverse other routes */
2768
2769                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2770                                 if ((*r) != (*rt)) {
2771                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2772                                         if (mt) {
2773                                                 mt->set_input_active (!others_are_already_on);
2774                                         }
2775                                 }
2776                         }
2777                 }
2778         }
2779 }
2780
2781 void
2782 Session::routes_using_input_from (const string& str, RouteList& rl)
2783 {
2784         boost::shared_ptr<RouteList> r = routes.reader();
2785
2786         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2787                 if ((*i)->input()->connected_to (str)) {
2788                         rl.push_back (*i);
2789                 }
2790         }
2791 }
2792
2793 boost::shared_ptr<Route>
2794 Session::route_by_name (string name)
2795 {
2796         boost::shared_ptr<RouteList> r = routes.reader ();
2797
2798         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2799                 if ((*i)->name() == name) {
2800                         return *i;
2801                 }
2802         }
2803
2804         return boost::shared_ptr<Route> ((Route*) 0);
2805 }
2806
2807 boost::shared_ptr<Route>
2808 Session::route_by_id (PBD::ID id)
2809 {
2810         boost::shared_ptr<RouteList> r = routes.reader ();
2811
2812         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2813                 if ((*i)->id() == id) {
2814                         return *i;
2815                 }
2816         }
2817
2818         return boost::shared_ptr<Route> ((Route*) 0);
2819 }
2820
2821 boost::shared_ptr<Track>
2822 Session::track_by_diskstream_id (PBD::ID id)
2823 {
2824         boost::shared_ptr<RouteList> r = routes.reader ();
2825
2826         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2827                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
2828                 if (t && t->using_diskstream_id (id)) {
2829                         return t;
2830                 }
2831         }
2832
2833         return boost::shared_ptr<Track> ();
2834 }
2835
2836 boost::shared_ptr<Route>
2837 Session::route_by_remote_id (uint32_t id)
2838 {
2839         boost::shared_ptr<RouteList> r = routes.reader ();
2840
2841         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2842                 if ((*i)->remote_control_id() == id) {
2843                         return *i;
2844                 }
2845         }
2846
2847         return boost::shared_ptr<Route> ((Route*) 0);
2848 }
2849
2850 void
2851 Session::playlist_region_added (boost::weak_ptr<Region> w)
2852 {
2853         boost::shared_ptr<Region> r = w.lock ();
2854         if (!r) {
2855                 return;
2856         }
2857
2858         /* These are the operations that are currently in progress... */
2859         list<GQuark> curr = _current_trans_quarks;
2860         curr.sort ();
2861
2862         /* ...and these are the operations during which we want to update
2863            the session range location markers.
2864         */
2865         list<GQuark> ops;
2866         ops.push_back (Operations::capture);
2867         ops.push_back (Operations::paste);
2868         ops.push_back (Operations::duplicate_region);
2869         ops.push_back (Operations::insert_file);
2870         ops.push_back (Operations::insert_region);
2871         ops.push_back (Operations::drag_region_brush);
2872         ops.push_back (Operations::region_drag);
2873         ops.push_back (Operations::selection_grab);
2874         ops.push_back (Operations::region_fill);
2875         ops.push_back (Operations::fill_selection);
2876         ops.push_back (Operations::create_region);
2877         ops.push_back (Operations::region_copy);
2878         ops.push_back (Operations::fixed_time_region_copy);
2879         ops.sort ();
2880
2881         /* See if any of the current operations match the ones that we want */
2882         list<GQuark> in;
2883         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2884
2885         /* If so, update the session range markers */
2886         if (!in.empty ()) {
2887                 maybe_update_session_range (r->position (), r->last_frame ());
2888         }
2889 }
2890
2891 /** Update the session range markers if a is before the current start or
2892  *  b is after the current end.
2893  */
2894 void
2895 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2896 {
2897         if (_state_of_the_state & Loading) {
2898                 return;
2899         }
2900
2901         if (_session_range_location == 0) {
2902
2903                 add_session_range_location (a, b);
2904
2905         } else {
2906
2907                 if (a < _session_range_location->start()) {
2908                         _session_range_location->set_start (a);
2909                 }
2910
2911                 if (b > _session_range_location->end()) {
2912                         _session_range_location->set_end (b);
2913                 }
2914         }
2915 }
2916
2917 void
2918 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2919 {
2920         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2921                 maybe_update_session_range (i->to, i->to + i->length);
2922         }
2923 }
2924
2925 void
2926 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2927 {
2928         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2929                 maybe_update_session_range (i->from, i->to);
2930         }
2931 }
2932
2933 /* Region management */
2934
2935 boost::shared_ptr<Region>
2936 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2937 {
2938         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2939         RegionFactory::RegionMap::const_iterator i;
2940         boost::shared_ptr<Region> region;
2941
2942         Glib::Threads::Mutex::Lock lm (region_lock);
2943
2944         for (i = regions.begin(); i != regions.end(); ++i) {
2945
2946                 region = i->second;
2947
2948                 if (region->whole_file()) {
2949
2950                         if (child->source_equivalent (region)) {
2951                                 return region;
2952                         }
2953                 }
2954         }
2955
2956         return boost::shared_ptr<Region> ();
2957 }
2958
2959 int
2960 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2961 {
2962         set<boost::shared_ptr<Region> > relevant_regions;
2963
2964         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2965                 RegionFactory::get_regions_using_source (*s, relevant_regions);
2966         }
2967
2968         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2969                 set<boost::shared_ptr<Region> >::iterator tmp;
2970
2971                 tmp = r;
2972                 ++tmp;
2973
2974                 playlists->destroy_region (*r);
2975                 RegionFactory::map_remove (*r);
2976
2977                 (*r)->drop_sources ();
2978                 (*r)->drop_references ();
2979
2980                 relevant_regions.erase (r);
2981
2982                 r = tmp;
2983         }
2984
2985         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2986
2987                 {
2988                         Glib::Threads::Mutex::Lock ls (source_lock);
2989                         /* remove from the main source list */
2990                         sources.erase ((*s)->id());
2991                 }
2992
2993                 (*s)->mark_for_remove ();
2994                 (*s)->drop_references ();
2995
2996                 s = srcs.erase (s);
2997         }
2998
2999         return 0;
3000 }
3001
3002 int
3003 Session::remove_last_capture ()
3004 {
3005         list<boost::shared_ptr<Source> > srcs;
3006
3007         boost::shared_ptr<RouteList> rl = routes.reader ();
3008         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3009                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3010                 if (!tr) {
3011                         continue;
3012                 }
3013
3014                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3015
3016                 if (!l.empty()) {
3017                         srcs.insert (srcs.end(), l.begin(), l.end());
3018                         l.clear ();
3019                 }
3020         }
3021
3022         destroy_sources (srcs);
3023
3024         save_state (_current_snapshot_name);
3025
3026         return 0;
3027 }
3028
3029 /* Source Management */
3030
3031 void
3032 Session::add_source (boost::shared_ptr<Source> source)
3033 {
3034         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3035         pair<SourceMap::iterator,bool> result;
3036
3037         entry.first = source->id();
3038         entry.second = source;
3039
3040         {
3041                 Glib::Threads::Mutex::Lock lm (source_lock);
3042                 result = sources.insert (entry);
3043         }
3044
3045         if (result.second) {
3046
3047                 /* yay, new source */
3048
3049                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3050
3051                 if (fs) {
3052                         if (!fs->within_session()) {
3053                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3054                         }
3055                 }
3056
3057                 set_dirty();
3058
3059                 boost::shared_ptr<AudioFileSource> afs;
3060
3061                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3062                         if (Config->get_auto_analyse_audio()) {
3063                                 Analyser::queue_source_for_analysis (source, false);
3064                         }
3065                 }
3066
3067                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3068         }
3069 }
3070
3071 void
3072 Session::remove_source (boost::weak_ptr<Source> src)
3073 {
3074         if (_state_of_the_state & Deletion) {
3075                 return;
3076         }
3077
3078         SourceMap::iterator i;
3079         boost::shared_ptr<Source> source = src.lock();
3080
3081         if (!source) {
3082                 return;
3083         }
3084
3085         {
3086                 Glib::Threads::Mutex::Lock lm (source_lock);
3087
3088                 if ((i = sources.find (source->id())) != sources.end()) {
3089                         sources.erase (i);
3090                 }
3091         }
3092
3093         if (!(_state_of_the_state & InCleanup)) {
3094
3095                 /* save state so we don't end up with a session file
3096                    referring to non-existent sources.
3097                 */
3098
3099                 save_state (_current_snapshot_name);
3100         }
3101 }
3102
3103 boost::shared_ptr<Source>
3104 Session::source_by_id (const PBD::ID& id)
3105 {
3106         Glib::Threads::Mutex::Lock lm (source_lock);
3107         SourceMap::iterator i;
3108         boost::shared_ptr<Source> source;
3109
3110         if ((i = sources.find (id)) != sources.end()) {
3111                 source = i->second;
3112         }
3113
3114         return source;
3115 }
3116
3117 boost::shared_ptr<Source>
3118 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3119 {
3120         Glib::Threads::Mutex::Lock lm (source_lock);
3121
3122         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3123                 boost::shared_ptr<AudioFileSource> afs
3124                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3125
3126                 if (afs && afs->path() == path && chn == afs->channel()) {
3127                         return afs;
3128                 }
3129         }
3130         return boost::shared_ptr<Source>();
3131 }
3132
3133 uint32_t
3134 Session::count_sources_by_origin (const string& path)
3135 {
3136         uint32_t cnt = 0;
3137         Glib::Threads::Mutex::Lock lm (source_lock);
3138
3139         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3140                 boost::shared_ptr<FileSource> fs
3141                         = boost::dynamic_pointer_cast<FileSource>(i->second);
3142
3143                 if (fs && fs->origin() == path) {
3144                         ++cnt;
3145                 }
3146         }
3147
3148         return cnt;
3149 }
3150
3151
3152 string
3153 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3154 {
3155         string look_for;
3156         string old_basename = PBD::basename_nosuffix (oldname);
3157         string new_legalized = legalize_for_path (newname);
3158
3159         /* note: we know (or assume) the old path is already valid */
3160
3161         if (destructive) {
3162
3163                 /* destructive file sources have a name of the form:
3164
3165                     /path/to/Tnnnn-NAME(%[LR])?.wav
3166
3167                     the task here is to replace NAME with the new name.
3168                 */
3169
3170                 string dir;
3171                 string prefix;
3172                 string::size_type dash;
3173
3174                 dir = Glib::path_get_dirname (path);
3175                 path = Glib::path_get_basename (path);
3176
3177                 /* '-' is not a legal character for the NAME part of the path */
3178
3179                 if ((dash = path.find_last_of ('-')) == string::npos) {
3180                         return "";
3181                 }
3182
3183                 prefix = path.substr (0, dash);
3184
3185                 path += prefix;
3186                 path += '-';
3187                 path += new_legalized;
3188                 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3189                 path = Glib::build_filename (dir, path);
3190
3191         } else {
3192
3193                 /* non-destructive file sources have a name of the form:
3194
3195                     /path/to/NAME-nnnnn(%[LR])?.ext
3196
3197                     the task here is to replace NAME with the new name.
3198                 */
3199
3200                 string dir;
3201                 string suffix;
3202                 string::size_type dash;
3203                 string::size_type postfix;
3204
3205                 dir = Glib::path_get_dirname (path);
3206                 path = Glib::path_get_basename (path);
3207
3208                 /* '-' is not a legal character for the NAME part of the path */
3209
3210                 if ((dash = path.find_last_of ('-')) == string::npos) {
3211                         return "";
3212                 }
3213
3214                 suffix = path.substr (dash+1);
3215
3216                 // Suffix is now everything after the dash. Now we need to eliminate
3217                 // the nnnnn part, which is done by either finding a '%' or a '.'
3218
3219                 postfix = suffix.find_last_of ("%");
3220                 if (postfix == string::npos) {
3221                         postfix = suffix.find_last_of ('.');
3222                 }
3223
3224                 if (postfix != string::npos) {
3225                         suffix = suffix.substr (postfix);
3226                 } else {
3227                         error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3228                         return "";
3229                 }
3230
3231                 const uint32_t limit = 10000;
3232                 char buf[PATH_MAX+1];
3233
3234                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3235
3236                         snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3237
3238                         if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3239                                 path = Glib::build_filename (dir, buf);
3240                                 break;
3241                         }
3242
3243                         path = "";
3244                 }
3245
3246                 if (path.empty()) {
3247                         fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3248                                                  newname) << endl;
3249                         /*NOTREACHED*/
3250                 }
3251         }
3252
3253         return path;
3254 }
3255
3256 /** Return the full path (in some session directory) for a new within-session source.
3257  * \a name must be a session-unique name that does not contain slashes
3258  *         (e.g. as returned by new_*_source_name)
3259  */
3260 string
3261 Session::new_source_path_from_name (DataType type, const string& name)
3262 {
3263         assert(name.find("/") == string::npos);
3264
3265         SessionDirectory sdir(get_best_session_directory_for_new_source());
3266
3267         std::string p;
3268         if (type == DataType::AUDIO) {
3269                 p = sdir.sound_path();
3270         } else if (type == DataType::MIDI) {
3271                 p = sdir.midi_path();
3272         } else {
3273                 error << "Unknown source type, unable to create file path" << endmsg;
3274                 return "";
3275         }
3276
3277         return Glib::build_filename (p, name);
3278 }
3279
3280 string
3281 Session::peak_path (string base) const
3282 {
3283         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3284 }
3285
3286 /** Return a unique name based on \a base for a new internal audio source */
3287 string
3288 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3289 {
3290         uint32_t cnt;
3291         char buf[PATH_MAX+1];
3292         const uint32_t limit = 10000;
3293         string legalized;
3294         string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3295
3296         buf[0] = '\0';
3297         legalized = legalize_for_path (base);
3298
3299         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3300         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3301
3302                 vector<space_and_path>::iterator i;
3303                 uint32_t existing = 0;
3304
3305                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3306
3307                         if (destructive) {
3308
3309                                 if (nchan < 2) {
3310                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3311                                                   cnt, legalized.c_str(), ext.c_str());
3312                                 } else if (nchan == 2) {
3313                                         if (chan == 0) {
3314                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3315                                                           cnt, legalized.c_str(), ext.c_str());
3316                                         } else {
3317                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3318                                                           cnt, legalized.c_str(), ext.c_str());
3319                                         }
3320                                 } else if (nchan < 26) {
3321                                         snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3322                                                   cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3323                                 } else {
3324                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3325                                                   cnt, legalized.c_str(), ext.c_str());
3326                                 }
3327
3328                         } else {
3329
3330                                 if (nchan < 2) {
3331                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3332                                 } else if (nchan == 2) {
3333                                         if (chan == 0) {
3334                                                 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3335                                         } else {
3336                                                 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3337                                         }
3338                                 } else if (nchan < 26) {
3339                                         snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3340                                 } else {
3341                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3342                                 }
3343                         }
3344
3345                         SessionDirectory sdir((*i).path);
3346
3347                         string spath = sdir.sound_path();
3348
3349                         /* note that we search *without* the extension so that
3350                            we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3351                            in the event that this new name is required for
3352                            a file format change.
3353                         */
3354
3355                         if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3356                                 existing++;
3357                                 break;
3358                         }
3359                 }
3360
3361                 if (existing == 0) {
3362                         break;
3363                 }
3364
3365                 if (cnt > limit) {
3366                         error << string_compose(
3367                                         _("There are already %1 recordings for %2, which I consider too many."),
3368                                         limit, base) << endmsg;
3369                         destroy ();
3370                         throw failed_constructor();
3371                 }
3372         }
3373
3374         return Glib::path_get_basename (buf);
3375 }
3376
3377 /** Create a new within-session audio source */
3378 boost::shared_ptr<AudioFileSource>
3379 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3380 {
3381         const string name    = new_audio_source_name (n, n_chans, chan, destructive);
3382         const string path    = new_source_path_from_name(DataType::AUDIO, name);
3383
3384         return boost::dynamic_pointer_cast<AudioFileSource> (
3385                 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3386 }
3387
3388 /** Return a unique name based on \a base for a new internal MIDI source */
3389 string
3390 Session::new_midi_source_name (const string& base)
3391 {
3392         uint32_t cnt;
3393         char buf[PATH_MAX+1];
3394         const uint32_t limit = 10000;
3395         string legalized;
3396
3397         buf[0] = '\0';
3398         legalized = legalize_for_path (base);
3399
3400         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3401         for (cnt = 1; cnt <= limit; ++cnt) {
3402
3403                 vector<space_and_path>::iterator i;
3404                 uint32_t existing = 0;
3405
3406                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3407
3408                         SessionDirectory sdir((*i).path);
3409
3410                         std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3411
3412                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3413
3414                         if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3415                                 existing++;
3416                         }
3417                 }
3418
3419                 if (existing == 0) {
3420                         break;
3421                 }
3422
3423                 if (cnt > limit) {
3424                         error << string_compose(
3425                                         _("There are already %1 recordings for %2, which I consider too many."),
3426                                         limit, base) << endmsg;
3427                         destroy ();
3428                         throw failed_constructor();
3429                 }
3430         }
3431
3432         return Glib::path_get_basename(buf);
3433 }
3434
3435
3436 /** Create a new within-session MIDI source */
3437 boost::shared_ptr<MidiSource>
3438 Session::create_midi_source_for_session (Track* track, string const & n)
3439 {
3440         /* try to use the existing write source for the track, to keep numbering sane
3441          */
3442
3443         if (track) {
3444                 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3445                   assert (mt);
3446                 */
3447
3448                 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3449
3450                 if (!l.empty()) {
3451                         assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3452                         return boost::dynamic_pointer_cast<MidiSource> (l.front());
3453                 }
3454         }
3455
3456         const string name = new_midi_source_name (n);
3457         const string path = new_source_path_from_name (DataType::MIDI, name);
3458
3459         return boost::dynamic_pointer_cast<SMFSource> (
3460                 SourceFactory::createWritable (
3461                         DataType::MIDI, *this, path, false, frame_rate()));
3462 }
3463
3464
3465 void
3466 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3467 {
3468         if (playlist->hidden()) {
3469                 return;
3470         }
3471
3472         playlists->add (playlist);
3473
3474         if (unused) {
3475                 playlist->release();
3476         }
3477
3478         set_dirty();
3479 }
3480
3481 void
3482 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3483 {
3484         if (_state_of_the_state & Deletion) {
3485                 return;
3486         }
3487
3488         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3489
3490         if (!playlist) {
3491                 return;
3492         }
3493
3494         playlists->remove (playlist);
3495
3496         set_dirty();
3497 }
3498
3499 void
3500 Session::set_audition (boost::shared_ptr<Region> r)
3501 {
3502         pending_audition_region = r;
3503         add_post_transport_work (PostTransportAudition);
3504         _butler->schedule_transport_work ();
3505 }
3506
3507 void
3508 Session::audition_playlist ()
3509 {
3510         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3511         ev->region.reset ();
3512         queue_event (ev);
3513 }
3514
3515 void
3516 Session::non_realtime_set_audition ()
3517 {
3518         assert (pending_audition_region);
3519         auditioner->audition_region (pending_audition_region);
3520         pending_audition_region.reset ();
3521         AuditionActive (true); /* EMIT SIGNAL */
3522 }
3523
3524 void
3525 Session::audition_region (boost::shared_ptr<Region> r)
3526 {
3527         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3528         ev->region = r;
3529         queue_event (ev);
3530 }
3531
3532 void
3533 Session::cancel_audition ()
3534 {
3535         if (auditioner->auditioning()) {
3536                 auditioner->cancel_audition ();
3537                 AuditionActive (false); /* EMIT SIGNAL */
3538         }
3539 }
3540
3541 bool
3542 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3543 {
3544         if (a->is_monitor()) {
3545                 return true;
3546         }
3547         if (b->is_monitor()) {
3548                 return false;
3549         }
3550         return a->order_key (MixerSort) < b->order_key (MixerSort);
3551 }
3552
3553 bool
3554 Session::is_auditioning () const
3555 {
3556         /* can be called before we have an auditioner object */
3557         if (auditioner) {
3558                 return auditioner->auditioning();
3559         } else {
3560                 return false;
3561         }
3562 }
3563
3564 void
3565 Session::graph_reordered ()
3566 {
3567         /* don't do this stuff if we are setting up connections
3568            from a set_state() call or creating new tracks. Ditto for deletion.
3569         */
3570
3571         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3572                 return;
3573         }
3574
3575         /* every track/bus asked for this to be handled but it was deferred because
3576            we were connecting. do it now.
3577         */
3578
3579         request_input_change_handling ();
3580
3581         resort_routes ();
3582
3583         /* force all diskstreams to update their capture offset values to
3584            reflect any changes in latencies within the graph.
3585         */
3586
3587         boost::shared_ptr<RouteList> rl = routes.reader ();
3588         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3589                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3590                 if (tr) {
3591                         tr->set_capture_offset ();
3592                 }
3593         }
3594 }
3595
3596 /** @return Number of frames that there is disk space available to write,
3597  *  if known.
3598  */
3599 boost::optional<framecnt_t>
3600 Session::available_capture_duration ()
3601 {
3602         Glib::Threads::Mutex::Lock lm (space_lock);
3603
3604         if (_total_free_4k_blocks_uncertain) {
3605                 return boost::optional<framecnt_t> ();
3606         }
3607
3608         float sample_bytes_on_disk = 4.0; // keep gcc happy
3609
3610         switch (config.get_native_file_data_format()) {
3611         case FormatFloat:
3612                 sample_bytes_on_disk = 4.0;
3613                 break;
3614
3615         case FormatInt24:
3616                 sample_bytes_on_disk = 3.0;
3617                 break;
3618
3619         case FormatInt16:
3620                 sample_bytes_on_disk = 2.0;
3621                 break;
3622
3623         default:
3624                 /* impossible, but keep some gcc versions happy */
3625                 fatal << string_compose (_("programming error: %1"),
3626                                          X_("illegal native file data format"))
3627                       << endmsg;
3628                 /*NOTREACHED*/
3629         }
3630
3631         double scale = 4096.0 / sample_bytes_on_disk;
3632
3633         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3634                 return max_framecnt;
3635         }
3636
3637         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3638 }
3639
3640 void
3641 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3642 {
3643         {
3644                 RCUWriter<BundleList> writer (_bundles);
3645                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3646                 b->push_back (bundle);
3647         }
3648
3649         BundleAdded (bundle); /* EMIT SIGNAL */
3650
3651         set_dirty();
3652 }
3653
3654 void
3655 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3656 {
3657         bool removed = false;
3658
3659         {
3660                 RCUWriter<BundleList> writer (_bundles);
3661                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3662                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3663
3664                 if (i != b->end()) {
3665                         b->erase (i);
3666                         removed = true;
3667                 }
3668         }
3669
3670         if (removed) {
3671                  BundleRemoved (bundle); /* EMIT SIGNAL */
3672         }
3673
3674         set_dirty();
3675 }
3676
3677 boost::shared_ptr<Bundle>
3678 Session::bundle_by_name (string name) const
3679 {
3680         boost::shared_ptr<BundleList> b = _bundles.reader ();
3681
3682         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3683                 if ((*i)->name() == name) {
3684                         return* i;
3685                 }
3686         }
3687
3688         return boost::shared_ptr<Bundle> ();
3689 }
3690
3691 void
3692 Session::tempo_map_changed (const PropertyChange&)
3693 {
3694         clear_clicks ();
3695
3696         playlists->update_after_tempo_map_change ();
3697
3698         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3699
3700         set_dirty ();
3701 }
3702
3703 void
3704 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3705 {
3706         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3707                 (*i)->recompute_frames_from_bbt ();
3708         }
3709 }
3710
3711 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3712  * the given count with the current block size.
3713  */
3714 void
3715 Session::ensure_buffers (ChanCount howmany)
3716 {
3717         BufferManager::ensure_buffers (howmany);
3718 }
3719
3720 void
3721 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3722 {
3723         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3724                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3725         }
3726 }
3727
3728 uint32_t
3729 Session::next_insert_id ()
3730 {
3731         /* this doesn't really loop forever. just think about it */
3732
3733         while (true) {
3734                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3735                         if (!insert_bitset[n]) {
3736                                 insert_bitset[n] = true;
3737                                 return n;
3738
3739                         }
3740                 }
3741
3742                 /* none available, so resize and try again */
3743
3744                 insert_bitset.resize (insert_bitset.size() + 16, false);
3745         }
3746 }
3747
3748 uint32_t
3749 Session::next_send_id ()
3750 {
3751         /* this doesn't really loop forever. just think about it */
3752
3753         while (true) {
3754                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3755                         if (!send_bitset[n]) {
3756                                 send_bitset[n] = true;
3757                                 return n;
3758
3759                         }
3760                 }
3761
3762                 /* none available, so resize and try again */
3763
3764                 send_bitset.resize (send_bitset.size() + 16, false);
3765         }
3766 }
3767
3768 uint32_t
3769 Session::next_aux_send_id ()
3770 {
3771         /* this doesn't really loop forever. just think about it */
3772
3773         while (true) {
3774                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3775                         if (!aux_send_bitset[n]) {
3776                                 aux_send_bitset[n] = true;
3777                                 return n;
3778
3779                         }
3780                 }
3781
3782                 /* none available, so resize and try again */
3783
3784                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3785         }
3786 }
3787
3788 uint32_t
3789 Session::next_return_id ()
3790 {
3791         /* this doesn't really loop forever. just think about it */
3792
3793         while (true) {
3794                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3795                         if (!return_bitset[n]) {
3796                                 return_bitset[n] = true;
3797                                 return n;
3798
3799                         }
3800                 }
3801
3802                 /* none available, so resize and try again */
3803
3804                 return_bitset.resize (return_bitset.size() + 16, false);
3805         }
3806 }
3807
3808 void
3809 Session::mark_send_id (uint32_t id)
3810 {
3811         if (id >= send_bitset.size()) {
3812                 send_bitset.resize (id+16, false);
3813         }
3814         if (send_bitset[id]) {
3815                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3816         }
3817         send_bitset[id] = true;
3818 }
3819
3820 void
3821 Session::mark_aux_send_id (uint32_t id)
3822 {
3823         if (id >= aux_send_bitset.size()) {
3824                 aux_send_bitset.resize (id+16, false);
3825         }
3826         if (aux_send_bitset[id]) {
3827                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3828         }
3829         aux_send_bitset[id] = true;
3830 }
3831
3832 void
3833 Session::mark_return_id (uint32_t id)
3834 {
3835         if (id >= return_bitset.size()) {
3836                 return_bitset.resize (id+16, false);
3837         }
3838         if (return_bitset[id]) {
3839                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3840         }
3841         return_bitset[id] = true;
3842 }
3843
3844 void
3845 Session::mark_insert_id (uint32_t id)
3846 {
3847         if (id >= insert_bitset.size()) {
3848                 insert_bitset.resize (id+16, false);
3849         }
3850         if (insert_bitset[id]) {
3851                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3852         }
3853         insert_bitset[id] = true;
3854 }
3855
3856 void
3857 Session::unmark_send_id (uint32_t id)
3858 {
3859         if (id < send_bitset.size()) {
3860                 send_bitset[id] = false;
3861         }
3862 }
3863
3864 void
3865 Session::unmark_aux_send_id (uint32_t id)
3866 {
3867         if (id < aux_send_bitset.size()) {
3868                 aux_send_bitset[id] = false;
3869         }
3870 }
3871
3872 void
3873 Session::unmark_return_id (uint32_t id)
3874 {
3875         if (id < return_bitset.size()) {
3876                 return_bitset[id] = false;
3877         }
3878 }
3879
3880 void
3881 Session::unmark_insert_id (uint32_t id)
3882 {
3883         if (id < insert_bitset.size()) {
3884                 insert_bitset[id] = false;
3885         }
3886 }
3887
3888 void
3889 Session::reset_native_file_format ()
3890 {
3891         boost::shared_ptr<RouteList> rl = routes.reader ();
3892         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3893                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3894                 if (tr) {
3895                         /* don't save state as we do this, there's no point
3896                          */
3897
3898                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3899                         tr->reset_write_sources (false);
3900                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3901                 }
3902         }
3903 }
3904
3905 bool
3906 Session::route_name_unique (string n) const
3907 {
3908         boost::shared_ptr<RouteList> r = routes.reader ();
3909
3910         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3911                 if ((*i)->name() == n) {
3912                         return false;
3913                 }
3914         }
3915
3916         return true;
3917 }
3918
3919 bool
3920 Session::route_name_internal (string n) const
3921 {
3922         if (auditioner && auditioner->name() == n) {
3923                 return true;
3924         }
3925
3926         if (_click_io && _click_io->name() == n) {
3927                 return true;
3928         }
3929
3930         return false;
3931 }
3932
3933 int
3934 Session::freeze_all (InterThreadInfo& itt)
3935 {
3936         boost::shared_ptr<RouteList> r = routes.reader ();
3937
3938         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3939
3940                 boost::shared_ptr<Track> t;
3941
3942                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3943                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3944                            of every track.
3945                         */
3946                         t->freeze_me (itt);
3947                 }
3948         }
3949
3950         return 0;
3951 }
3952
3953 boost::shared_ptr<Region>
3954 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3955                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3956                           InterThreadInfo& itt,
3957                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3958                           bool for_export)
3959 {
3960         boost::shared_ptr<Region> result;
3961         boost::shared_ptr<Playlist> playlist;
3962         boost::shared_ptr<AudioFileSource> fsource;
3963         uint32_t x;
3964         char buf[PATH_MAX+1];
3965         ChanCount diskstream_channels (track.n_channels());
3966         framepos_t position;
3967         framecnt_t this_chunk;
3968         framepos_t to_do;
3969         BufferSet buffers;
3970         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3971         const string sound_dir = sdir.sound_path();
3972         framepos_t len = end - start;
3973         bool need_block_size_reset = false;
3974         string ext;
3975         ChanCount const max_proc = track.max_processor_streams ();
3976
3977         if (end <= start) {
3978                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3979                                          end, start) << endmsg;
3980                 return result;
3981         }
3982
3983         const framecnt_t chunk_size = (256 * 1024)/4;
3984
3985         // block all process callback handling
3986
3987         block_processing ();
3988
3989         /* call tree *MUST* hold route_lock */
3990
3991         if ((playlist = track.playlist()) == 0) {
3992                 goto out;
3993         }
3994
3995         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3996
3997         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
3998
3999                 for (x = 0; x < 99999; ++x) {
4000                         snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
4001                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4002                                 break;
4003                         }
4004                 }
4005
4006                 if (x == 99999) {
4007                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4008                         goto out;
4009                 }
4010
4011                 try {
4012                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4013                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4014                 }
4015
4016                 catch (failed_constructor& err) {
4017                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4018                         goto out;
4019                 }
4020
4021                 srcs.push_back (fsource);
4022         }
4023
4024         /* tell redirects that care that we are about to use a much larger
4025          * blocksize. this will flush all plugins too, so that they are ready
4026          * to be used for this process.
4027          */
4028
4029         need_block_size_reset = true;
4030         track.set_block_size (chunk_size);
4031
4032         position = start;
4033         to_do = len;
4034
4035         /* create a set of reasonably-sized buffers */
4036         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4037         buffers.set_count (max_proc);
4038
4039         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4040                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4041                 if (afs)
4042                         afs->prepare_for_peakfile_writes ();
4043         }
4044
4045         while (to_do && !itt.cancel) {
4046
4047                 this_chunk = min (to_do, chunk_size);
4048
4049                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4050                         goto out;
4051                 }
4052
4053                 uint32_t n = 0;
4054                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4055                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4056
4057                         if (afs) {
4058                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4059                                         goto out;
4060                                 }
4061                         }
4062                 }
4063
4064                 start += this_chunk;
4065                 to_do -= this_chunk;
4066
4067                 itt.progress = (float) (1.0 - ((double) to_do / len));
4068
4069         }
4070
4071         if (!itt.cancel) {
4072
4073                 time_t now;
4074                 struct tm* xnow;
4075                 time (&now);
4076                 xnow = localtime (&now);
4077
4078                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4079                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4080
4081                         if (afs) {
4082                                 afs->update_header (position, *xnow, now);
4083                                 afs->flush_header ();
4084                         }
4085                 }
4086
4087                 /* construct a region to represent the bounced material */
4088
4089                 PropertyList plist;
4090
4091                 plist.add (Properties::start, 0);
4092                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4093                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4094
4095                 result = RegionFactory::create (srcs, plist);
4096
4097         }
4098
4099   out:
4100         if (!result) {
4101                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4102                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4103
4104                         if (afs) {
4105                                 afs->mark_for_remove ();
4106                         }
4107
4108                         (*src)->drop_references ();
4109                 }
4110
4111         } else {
4112                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4113                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4114
4115                         if (afs)
4116                                 afs->done_with_peakfile_writes ();
4117                 }
4118         }
4119
4120
4121         if (need_block_size_reset) {
4122                 track.set_block_size (get_block_size());
4123         }
4124
4125         unblock_processing ();
4126
4127         return result;
4128 }
4129
4130 gain_t*
4131 Session::gain_automation_buffer() const
4132 {
4133         return ProcessThread::gain_automation_buffer ();
4134 }
4135
4136 gain_t*
4137 Session::send_gain_automation_buffer() const
4138 {
4139         return ProcessThread::send_gain_automation_buffer ();
4140 }
4141
4142 pan_t**
4143 Session::pan_automation_buffer() const
4144 {
4145         return ProcessThread::pan_automation_buffer ();
4146 }
4147
4148 BufferSet&
4149 Session::get_silent_buffers (ChanCount count)
4150 {
4151         return ProcessThread::get_silent_buffers (count);
4152 }
4153
4154 BufferSet&
4155 Session::get_scratch_buffers (ChanCount count)
4156 {
4157         return ProcessThread::get_scratch_buffers (count);
4158 }
4159
4160 BufferSet&
4161 Session::get_mix_buffers (ChanCount count)
4162 {
4163         return ProcessThread::get_mix_buffers (count);
4164 }
4165
4166 uint32_t
4167 Session::ntracks () const
4168 {
4169         uint32_t n = 0;
4170         boost::shared_ptr<RouteList> r = routes.reader ();
4171
4172         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4173                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4174                         ++n;
4175                 }
4176         }
4177
4178         return n;
4179 }
4180
4181 uint32_t
4182 Session::nbusses () const
4183 {
4184         uint32_t n = 0;
4185         boost::shared_ptr<RouteList> r = routes.reader ();
4186
4187         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4188                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4189                         ++n;
4190                 }
4191         }
4192
4193         return n;
4194 }
4195
4196 void
4197 Session::add_automation_list(AutomationList *al)
4198 {
4199         automation_lists[al->id()] = al;
4200 }
4201
4202 /** @return true if there is at least one record-enabled track, otherwise false */
4203 bool
4204 Session::have_rec_enabled_track () const
4205 {
4206         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4207 }
4208
4209 /** Update the state of our rec-enabled tracks flag */
4210 void
4211 Session::update_have_rec_enabled_track ()
4212 {
4213         boost::shared_ptr<RouteList> rl = routes.reader ();
4214         RouteList::iterator i = rl->begin();
4215         while (i != rl->end ()) {
4216
4217                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4218                 if (tr && tr->record_enabled ()) {
4219                         break;
4220                 }
4221
4222                 ++i;
4223         }
4224
4225         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4226
4227         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4228
4229         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4230                 RecordStateChanged (); /* EMIT SIGNAL */
4231         }
4232 }
4233
4234 void
4235 Session::listen_position_changed ()
4236 {
4237         boost::shared_ptr<RouteList> r = routes.reader ();
4238
4239         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4240                 (*i)->listen_position_changed ();
4241         }
4242 }
4243
4244 void
4245 Session::solo_control_mode_changed ()
4246 {
4247         /* cancel all solo or all listen when solo control mode changes */
4248
4249         if (soloing()) {
4250                 set_solo (get_routes(), false);
4251         } else if (listening()) {
4252                 set_listen (get_routes(), false);
4253         }
4254 }
4255
4256 /** Called when a property of one of our route groups changes */
4257 void
4258 Session::route_group_property_changed (RouteGroup* rg)
4259 {
4260         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4261 }
4262
4263 /** Called when a route is added to one of our route groups */
4264 void
4265 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4266 {
4267         RouteAddedToRouteGroup (rg, r);
4268 }
4269
4270 /** Called when a route is removed from one of our route groups */
4271 void
4272 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4273 {
4274         RouteRemovedFromRouteGroup (rg, r);
4275 }
4276
4277 boost::shared_ptr<RouteList>
4278 Session::get_routes_with_regions_at (framepos_t const p) const
4279 {
4280         boost::shared_ptr<RouteList> r = routes.reader ();
4281         boost::shared_ptr<RouteList> rl (new RouteList);
4282
4283         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4284                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4285                 if (!tr) {
4286                         continue;
4287                 }
4288
4289                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4290                 if (!pl) {
4291                         continue;
4292                 }
4293
4294                 if (pl->has_region_at (p)) {
4295                         rl->push_back (*i);
4296                 }
4297         }
4298
4299         return rl;
4300 }
4301
4302 void
4303 Session::goto_end ()
4304 {
4305         if (_session_range_location) {
4306                 request_locate (_session_range_location->end(), false);
4307         } else {
4308                 request_locate (0, false);
4309         }
4310 }
4311
4312 void
4313 Session::goto_start ()
4314 {
4315         if (_session_range_location) {
4316                 request_locate (_session_range_location->start(), false);
4317         } else {
4318                 request_locate (0, false);
4319         }
4320 }
4321
4322 framepos_t
4323 Session::current_start_frame () const
4324 {
4325         return _session_range_location ? _session_range_location->start() : 0;
4326 }
4327
4328 framepos_t
4329 Session::current_end_frame () const
4330 {
4331         return _session_range_location ? _session_range_location->end() : 0;
4332 }
4333
4334 void
4335 Session::add_session_range_location (framepos_t start, framepos_t end)
4336 {
4337         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4338         _locations->add (_session_range_location);
4339 }
4340
4341 void
4342 Session::step_edit_status_change (bool yn)
4343 {
4344         bool send = false;
4345
4346         bool val = false;
4347         if (yn) {
4348                 send = (_step_editors == 0);
4349                 val = true;
4350
4351                 _step_editors++;
4352         } else {
4353                 send = (_step_editors == 1);
4354                 val = false;
4355
4356                 if (_step_editors > 0) {
4357                         _step_editors--;
4358                 }
4359         }
4360
4361         if (send) {
4362                 StepEditStatusChange (val);
4363         }
4364 }
4365
4366
4367 void
4368 Session::start_time_changed (framepos_t old)
4369 {
4370         /* Update the auto loop range to match the session range
4371            (unless the auto loop range has been changed by the user)
4372         */
4373
4374         Location* s = _locations->session_range_location ();
4375         if (s == 0) {
4376                 return;
4377         }
4378
4379         Location* l = _locations->auto_loop_location ();
4380
4381         if (l && l->start() == old) {
4382                 l->set_start (s->start(), true);
4383         }
4384 }
4385
4386 void
4387 Session::end_time_changed (framepos_t old)
4388 {
4389         /* Update the auto loop range to match the session range
4390            (unless the auto loop range has been changed by the user)
4391         */
4392
4393         Location* s = _locations->session_range_location ();
4394         if (s == 0) {
4395                 return;
4396         }
4397
4398         Location* l = _locations->auto_loop_location ();
4399
4400         if (l && l->end() == old) {
4401                 l->set_end (s->end(), true);
4402         }
4403 }
4404
4405 string
4406 Session::source_search_path (DataType type) const
4407 {
4408         vector<string> s;
4409
4410         if (session_dirs.size() == 1) {
4411                 switch (type) {
4412                 case DataType::AUDIO:
4413                         s.push_back (_session_dir->sound_path());
4414                         break;
4415                 case DataType::MIDI:
4416                         s.push_back (_session_dir->midi_path());
4417                         break;
4418                 }
4419         } else {
4420                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4421                         SessionDirectory sdir (i->path);
4422                         switch (type) {
4423                         case DataType::AUDIO:
4424                                 s.push_back (sdir.sound_path());
4425                                 break;
4426                         case DataType::MIDI:
4427                                 s.push_back (sdir.midi_path());
4428                                 break;
4429                         }
4430                 }
4431         }
4432
4433         if (type == DataType::AUDIO) {
4434                 const string sound_path_2X = _session_dir->sound_path_2X();
4435                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4436                         if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
4437                                 s.push_back (sound_path_2X);
4438                         }
4439                 }
4440         }
4441
4442         /* now check the explicit (possibly user-specified) search path
4443          */
4444
4445         vector<string> dirs;
4446
4447         switch (type) {
4448         case DataType::AUDIO:
4449                 split (config.get_audio_search_path (), dirs, ':');
4450                 break;
4451         case DataType::MIDI:
4452                 split (config.get_midi_search_path (), dirs, ':');
4453                 break;
4454         }
4455
4456         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4457                 if (find (s.begin(), s.end(), *i) == s.end()) {
4458                         s.push_back (*i);
4459                 }
4460         }
4461
4462         string search_path;
4463
4464         for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4465                 if (!search_path.empty()) {
4466                         search_path += ':';
4467                 }
4468                 search_path += *si;
4469         }
4470
4471         return search_path;
4472 }
4473
4474 void
4475 Session::ensure_search_path_includes (const string& path, DataType type)
4476 {
4477         string search_path;
4478         vector<string> dirs;
4479
4480         if (path == ".") {
4481                 return;
4482         }
4483
4484         switch (type) {
4485         case DataType::AUDIO:
4486                 search_path = config.get_audio_search_path ();
4487                 break;
4488         case DataType::MIDI:
4489                 search_path = config.get_midi_search_path ();
4490                 break;
4491         }
4492
4493         split (search_path, dirs, ':');
4494
4495         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4496                 /* No need to add this new directory if it has the same inode as
4497                    an existing one; checking inode rather than name prevents duplicated
4498                    directories when we are using symlinks.
4499
4500                    On Windows, I think we could just do if (*i == path) here.
4501                 */
4502                 if (PBD::equivalent_paths (*i, path)) {
4503                         return;
4504                 }
4505         }
4506
4507         if (!search_path.empty()) {
4508                 search_path += ':';
4509         }
4510
4511         search_path += path;
4512
4513         switch (type) {
4514         case DataType::AUDIO:
4515                 config.set_audio_search_path (search_path);
4516                 break;
4517         case DataType::MIDI:
4518                 config.set_midi_search_path (search_path);
4519                 break;
4520         }
4521 }
4522
4523 boost::shared_ptr<Speakers>
4524 Session::get_speakers()
4525 {
4526         return _speakers;
4527 }
4528
4529 list<string>
4530 Session::unknown_processors () const
4531 {
4532         list<string> p;
4533
4534         boost::shared_ptr<RouteList> r = routes.reader ();
4535         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4536                 list<string> t = (*i)->unknown_processors ();
4537                 copy (t.begin(), t.end(), back_inserter (p));
4538         }
4539
4540         p.sort ();
4541         p.unique ();
4542
4543         return p;
4544 }
4545
4546 void
4547 Session::update_latency (bool playback)
4548 {
4549         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4550
4551         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4552                 return;
4553         }
4554
4555         boost::shared_ptr<RouteList> r = routes.reader ();
4556         framecnt_t max_latency = 0;
4557
4558         if (playback) {
4559                 /* reverse the list so that we work backwards from the last route to run to the first */
4560                 RouteList* rl = routes.reader().get();
4561                 r.reset (new RouteList (*rl));
4562                 reverse (r->begin(), r->end());
4563         }
4564
4565         /* compute actual latency values for the given direction and store them all in per-port
4566            structures. this will also publish the same values (to JACK) so that computation of latency
4567            for routes can consistently use public latency values.
4568         */
4569
4570         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4571                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4572         }
4573
4574         /* because we latency compensate playback, our published playback latencies should
4575            be the same for all output ports - all material played back by ardour has
4576            the same latency, whether its caused by plugins or by latency compensation. since
4577            these may differ from the values computed above, reset all playback port latencies
4578            to the same value.
4579         */
4580
4581         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4582
4583         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4584                 (*i)->set_public_port_latencies (max_latency, playback);
4585         }
4586
4587         if (playback) {
4588
4589                 post_playback_latency ();
4590
4591         } else {
4592
4593                 post_capture_latency ();
4594         }
4595
4596         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4597 }
4598
4599 void
4600 Session::post_playback_latency ()
4601 {
4602         set_worst_playback_latency ();
4603
4604         boost::shared_ptr<RouteList> r = routes.reader ();
4605
4606         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4607                 if (!(*i)->is_hidden() && ((*i)->active())) {
4608                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4609                 }
4610         }
4611
4612         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4613                 (*i)->set_latency_compensation (_worst_track_latency);
4614         }
4615 }
4616
4617 void
4618 Session::post_capture_latency ()
4619 {
4620         set_worst_capture_latency ();
4621
4622         /* reflect any changes in capture latencies into capture offsets
4623          */
4624
4625         boost::shared_ptr<RouteList> rl = routes.reader();
4626         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4627                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4628                 if (tr) {
4629                         tr->set_capture_offset ();
4630                 }
4631         }
4632 }
4633
4634 void
4635 Session::initialize_latencies ()
4636 {
4637         {
4638                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4639                 update_latency (false);
4640                 update_latency (true);
4641         }
4642
4643         set_worst_io_latencies ();
4644 }
4645
4646 void
4647 Session::set_worst_io_latencies ()
4648 {
4649         set_worst_playback_latency ();
4650         set_worst_capture_latency ();
4651 }
4652
4653 void
4654 Session::set_worst_playback_latency ()
4655 {
4656         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4657                 return;
4658         }
4659
4660         _worst_output_latency = 0;
4661
4662         if (!_engine.connected()) {
4663                 return;
4664         }
4665
4666         boost::shared_ptr<RouteList> r = routes.reader ();
4667
4668         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4669                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4670         }
4671
4672         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4673 }
4674
4675 void
4676 Session::set_worst_capture_latency ()
4677 {
4678         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4679                 return;
4680         }
4681
4682         _worst_input_latency = 0;
4683
4684         if (!_engine.connected()) {
4685                 return;
4686         }
4687
4688         boost::shared_ptr<RouteList> r = routes.reader ();
4689
4690         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4691                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4692         }
4693
4694         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4695 }
4696
4697 void
4698 Session::update_latency_compensation (bool force_whole_graph)
4699 {
4700         bool some_track_latency_changed = false;
4701
4702         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4703                 return;
4704         }
4705
4706         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4707
4708         _worst_track_latency = 0;
4709
4710         boost::shared_ptr<RouteList> r = routes.reader ();
4711
4712         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4713                 if (!(*i)->is_hidden() && ((*i)->active())) {
4714                         framecnt_t tl;
4715                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4716                                 some_track_latency_changed = true;
4717                         }
4718                         _worst_track_latency = max (tl, _worst_track_latency);
4719                 }
4720         }
4721
4722         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4723                                                      (some_track_latency_changed ? "yes" : "no")));
4724
4725         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4726
4727         if (some_track_latency_changed || force_whole_graph)  {
4728                 _engine.update_latencies ();
4729         }
4730
4731
4732         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4733                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4734                 if (!tr) {
4735                         continue;
4736                 }
4737                 tr->set_capture_offset ();
4738         }
4739 }
4740
4741 char
4742 Session::session_name_is_legal (const string& path)
4743 {
4744         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4745
4746         for (int i = 0; illegal_chars[i]; ++i) {
4747                 if (path.find (illegal_chars[i]) != string::npos) {
4748                         return illegal_chars[i];
4749                 }
4750         }
4751
4752         return 0;
4753 }
4754
4755 uint32_t
4756 Session::next_control_id () const
4757 {
4758         int subtract = 0;
4759
4760         /* the monitor bus remote ID is in a different
4761          * "namespace" than regular routes. its existence doesn't
4762          * affect normal (low) numbered routes.
4763          */
4764
4765         if (_monitor_out) {
4766                 subtract++;
4767         }
4768
4769         return nroutes() - subtract;
4770 }
4771
4772 void
4773 Session::notify_remote_id_change ()
4774 {
4775         if (deletion_in_progress()) {
4776                 return;
4777         }
4778
4779         switch (Config->get_remote_model()) {
4780         case MixerSort:
4781         case EditorSort:
4782                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4783                 break;
4784         default:
4785                 break;
4786         }
4787 }
4788
4789 void
4790 Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
4791 {
4792         if (deletion_in_progress()) {
4793                 return;
4794         }
4795
4796         /* tell everyone that something has happened to the sort keys
4797            and let them sync up with the change(s)
4798            this will give objects that manage the sort order keys the
4799            opportunity to keep them in sync if they wish to.
4800         */
4801
4802         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
4803
4804         Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
4805
4806         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4807 }
4808
4809 bool
4810 Session::operation_in_progress (GQuark op) const
4811 {
4812         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4813 }
4814
4815 boost::shared_ptr<Port>
4816 Session::ltc_input_port () const
4817 {
4818         return _ltc_input->nth (0);
4819 }
4820
4821 boost::shared_ptr<Port>
4822 Session::ltc_output_port () const
4823 {
4824         return _ltc_output->nth (0);
4825 }
4826
4827 void
4828 Session::reconnect_ltc_input ()
4829 {
4830         if (_ltc_input) {
4831
4832                 string src = Config->get_ltc_source_port();
4833
4834                 _ltc_input->disconnect (this);
4835
4836                 if (src != _("None") && !src.empty())  {
4837                         _ltc_input->nth (0)->connect (src);
4838                 }
4839         }
4840 }
4841
4842 void
4843 Session::reconnect_ltc_output ()
4844 {
4845         if (_ltc_output) {
4846
4847 #if 0
4848                 string src = Config->get_ltc_sink_port();
4849
4850                 _ltc_output->disconnect (this);
4851
4852                 if (src != _("None") && !src.empty())  {
4853                         _ltc_output->nth (0)->connect (src);
4854                 }
4855 #endif
4856         }
4857 }