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_auditioner()) {
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, const std::string& name_base)
2041 {
2042         RouteList ret;
2043         uint32_t control_id;
2044         XMLTree tree;
2045         uint32_t number = 0;
2046         const uint32_t being_added = how_many;
2047
2048         if (!tree.read (template_path.c_str())) {
2049                 return ret;
2050         }
2051
2052         XMLNode* node = tree.root();
2053
2054         IO::disable_connecting ();
2055
2056         control_id = next_control_id ();
2057
2058         while (how_many) {
2059
2060                 XMLNode node_copy (*node);
2061
2062                 /* Remove IDs of everything so that new ones are used */
2063                 node_copy.remove_property_recursively (X_("id"));
2064
2065                 try {
2066                         char name[32];
2067
2068                         if (!name_base.empty()) {
2069
2070                                 /* if we're adding more than one routes, force
2071                                  * all the names of the new routes to be
2072                                  * numbered, via the final parameter.
2073                                  */
2074
2075                                 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2076                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2077                                         /*NOTREACHDE*/
2078                                 }
2079
2080                         } else {
2081
2082                                 string const route_name  = node_copy.property(X_("name"))->value ();
2083
2084                                 /* generate a new name by adding a number to the end of the template name */
2085                                 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2086                                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2087                                         /*NOTREACHED*/
2088                                 }
2089                         }
2090
2091                         /* set this name in the XML description that we are about to use */
2092                         Route::set_name_in_state (node_copy, name);
2093
2094                         /* trim bitslots from listen sends so that new ones are used */
2095                         XMLNodeList children = node_copy.children ();
2096                         for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2097                                 if ((*i)->name() == X_("Processor")) {
2098                                         XMLProperty* role = (*i)->property (X_("role"));
2099                                         if (role && role->value() == X_("Listen")) {
2100                                                 (*i)->remove_property (X_("bitslot"));
2101                                         }
2102                                 }
2103                         }
2104
2105                         boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2106
2107                         if (route == 0) {
2108                                 error << _("Session: cannot create track/bus from template description") << endmsg;
2109                                 goto out;
2110                         }
2111
2112                         if (boost::dynamic_pointer_cast<Track>(route)) {
2113                                 /* force input/output change signals so that the new diskstream
2114                                    picks up the configuration of the route. During session
2115                                    loading this normally happens in a different way.
2116                                 */
2117
2118                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2119
2120                                 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2121                                 change.after = route->input()->n_ports();
2122                                 route->input()->changed (change, this);
2123                                 change.after = route->output()->n_ports();
2124                                 route->output()->changed (change, this);
2125                         }
2126
2127                         route->set_remote_control_id (control_id);
2128                         ++control_id;
2129
2130                         ret.push_back (route);
2131                 }
2132
2133                 catch (failed_constructor &err) {
2134                         error << _("Session: could not create new route from template") << endmsg;
2135                         goto out;
2136                 }
2137
2138                 catch (AudioEngine::PortRegistrationFailure& pfe) {
2139                         error << pfe.what() << endmsg;
2140                         goto out;
2141                 }
2142
2143                 --how_many;
2144         }
2145
2146   out:
2147         if (!ret.empty()) {
2148                 add_routes (ret, true, true, true);
2149                 IO::enable_connecting ();
2150         }
2151
2152         return ret;
2153 }
2154
2155 void
2156 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2157 {
2158         try {
2159                 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2160                 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2161
2162         } catch (...) {
2163                 error << _("Adding new tracks/busses failed") << endmsg;
2164         }
2165
2166         graph_reordered ();
2167
2168         update_latency (true);
2169         update_latency (false);
2170
2171         set_dirty();
2172
2173         if (save) {
2174                 save_state (_current_snapshot_name);
2175         }
2176
2177         RouteAdded (new_routes); /* EMIT SIGNAL */
2178 }
2179
2180 void
2181 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
2182 {
2183         ChanCount existing_inputs;
2184         ChanCount existing_outputs;
2185         uint32_t order = next_control_id();
2186
2187         count_existing_track_channels (existing_inputs, existing_outputs);
2188
2189         {
2190                 RCUWriter<RouteList> writer (routes);
2191                 boost::shared_ptr<RouteList> r = writer.get_copy ();
2192                 r->insert (r->end(), new_routes.begin(), new_routes.end());
2193
2194                 /* if there is no control out and we're not in the middle of loading,
2195                    resort the graph here. if there is a control out, we will resort
2196                    toward the end of this method. if we are in the middle of loading,
2197                    we will resort when done.
2198                 */
2199
2200                 if (!_monitor_out && IO::connecting_legal) {
2201                         resort_routes_using (r);
2202                 }
2203         }
2204
2205         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2206
2207                 boost::weak_ptr<Route> wpr (*x);
2208                 boost::shared_ptr<Route> r (*x);
2209
2210                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
2211                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
2212                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
2213                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
2214                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
2215                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
2216
2217                 if (r->is_master()) {
2218                         _master_out = r;
2219                 }
2220
2221                 if (r->is_monitor()) {
2222                         _monitor_out = r;
2223                 }
2224
2225                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
2226                 if (tr) {
2227                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
2228                         track_playlist_changed (boost::weak_ptr<Track> (tr));
2229                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
2230
2231                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
2232                         if (mt) {
2233                                 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
2234                                 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
2235                         }
2236                 }
2237
2238
2239                 if (input_auto_connect || output_auto_connect) {
2240                         auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
2241                 }
2242
2243                 /* order keys are a GUI responsibility but we need to set up
2244                    reasonable defaults because they also affect the remote control
2245                    ID in most situations.
2246                 */
2247
2248                 if (!r->has_order_key (EditorSort)) {
2249                         if (r->is_auditioner()) {
2250                                 /* use an arbitrarily high value */
2251                                 r->set_order_key (EditorSort, UINT_MAX);
2252                                 r->set_order_key (MixerSort, UINT_MAX);
2253                         } else {
2254                                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
2255                                 r->set_order_key (EditorSort, order);
2256                                 r->set_order_key (MixerSort, order);
2257                                 order++;
2258                         }
2259                 }
2260
2261                 ARDOUR::GUIIdle ();
2262         }
2263
2264         if (_monitor_out && IO::connecting_legal) {
2265                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
2266
2267                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2268                         if ((*x)->is_monitor()) {
2269                                 /* relax */
2270                         } else if ((*x)->is_master()) {
2271                                         /* relax */
2272                         } else {
2273                                 (*x)->enable_monitor_send ();
2274                         }
2275                 }
2276         }
2277 }
2278
2279 void
2280 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
2281 {
2282         boost::shared_ptr<RouteList> r = routes.reader ();
2283         boost::shared_ptr<Send> s;
2284
2285         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2286                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2287                         s->amp()->gain_control()->set_value (0.0);
2288                 }
2289         }
2290 }
2291
2292 void
2293 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
2294 {
2295         boost::shared_ptr<RouteList> r = routes.reader ();
2296         boost::shared_ptr<Send> s;
2297
2298         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2299                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2300                         s->amp()->gain_control()->set_value (1.0);
2301                 }
2302         }
2303 }
2304
2305 void
2306 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
2307 {
2308         boost::shared_ptr<RouteList> r = routes.reader ();
2309         boost::shared_ptr<Send> s;
2310
2311         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2312                 if ((s = (*i)->internal_send_for (dest)) != 0) {
2313                         s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2314                 }
2315         }
2316 }
2317
2318 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
2319 void
2320 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
2321 {
2322         boost::shared_ptr<RouteList> r = routes.reader ();
2323         boost::shared_ptr<RouteList> t (new RouteList);
2324
2325         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2326                 /* no MIDI sends because there are no MIDI busses yet */
2327                 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
2328                         t->push_back (*i);
2329                 }
2330         }
2331
2332         add_internal_sends (dest, p, t);
2333 }
2334
2335 void
2336 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2337 {
2338         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2339                 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
2340         }
2341 }
2342
2343 void
2344 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
2345 {
2346         add_internal_send (dest, sender->before_processor_for_index (index), sender);
2347 }
2348
2349 void
2350 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
2351 {
2352         if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
2353                 return;
2354         }
2355
2356         if (!dest->internal_return()) {
2357                 dest->add_internal_return ();
2358         }
2359
2360         sender->add_aux_send (dest, before);
2361
2362         graph_reordered ();
2363 }
2364
2365 void
2366 Session::remove_route (boost::shared_ptr<Route> route)
2367 {
2368         if (route == _master_out) {
2369                 return;
2370         }
2371
2372         route->set_solo (false, this);
2373
2374         {
2375                 RCUWriter<RouteList> writer (routes);
2376                 boost::shared_ptr<RouteList> rs = writer.get_copy ();
2377
2378                 rs->remove (route);
2379
2380                 /* deleting the master out seems like a dumb
2381                    idea, but its more of a UI policy issue
2382                    than our concern.
2383                 */
2384
2385                 if (route == _master_out) {
2386                         _master_out = boost::shared_ptr<Route> ();
2387                 }
2388
2389                 if (route == _monitor_out) {
2390                         _monitor_out.reset ();
2391                 }
2392
2393                 /* writer goes out of scope, forces route list update */
2394         }
2395
2396         update_route_solo_state ();
2397
2398         // We need to disconnect the route's inputs and outputs
2399
2400         route->input()->disconnect (0);
2401         route->output()->disconnect (0);
2402
2403         /* if the route had internal sends sending to it, remove them */
2404         if (route->internal_return()) {
2405
2406                 boost::shared_ptr<RouteList> r = routes.reader ();
2407                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2408                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2409                         if (s) {
2410                                 (*i)->remove_processor (s);
2411                         }
2412                 }
2413         }
2414
2415         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
2416         if (mt && mt->step_editing()) {
2417                 if (_step_editors > 0) {
2418                         _step_editors--;
2419                 }
2420         }
2421
2422         update_latency_compensation ();
2423         set_dirty();
2424
2425         /* Re-sort routes to remove the graph's current references to the one that is
2426          * going away, then flush old references out of the graph.
2427          */
2428
2429         resort_routes ();
2430         if (_process_graph) {
2431                 _process_graph->clear_other_chain ();
2432         }
2433
2434         /* get rid of it from the dead wood collection in the route list manager */
2435
2436         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2437
2438         routes.flush ();
2439
2440         /* try to cause everyone to drop their references */
2441
2442         route->drop_references ();
2443
2444         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2445
2446         /* save the new state of the world */
2447
2448         if (save_state (_current_snapshot_name)) {
2449                 save_history (_current_snapshot_name);
2450         }
2451 }
2452
2453 void
2454 Session::route_mute_changed (void* /*src*/)
2455 {
2456         set_dirty ();
2457 }
2458
2459 void
2460 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2461 {
2462         boost::shared_ptr<Route> route = wpr.lock();
2463         if (!route) {
2464                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2465                 return;
2466         }
2467
2468         if (route->listening_via_monitor ()) {
2469
2470                 if (Config->get_exclusive_solo()) {
2471                         /* new listen: disable all other listen */
2472                         boost::shared_ptr<RouteList> r = routes.reader ();
2473                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2474                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
2475                                         continue;
2476                                 }
2477                                 (*i)->set_listen (false, this);
2478                         }
2479                 }
2480
2481                 _listen_cnt++;
2482
2483         } else if (_listen_cnt > 0) {
2484
2485                 _listen_cnt--;
2486         }
2487
2488         update_route_solo_state ();
2489 }
2490 void
2491 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2492 {
2493         boost::shared_ptr<Route> route = wpr.lock ();
2494
2495         if (!route) {
2496                 /* should not happen */
2497                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2498                 return;
2499         }
2500
2501         bool send_changed = false;
2502
2503         if (route->solo_isolated()) {
2504                 if (_solo_isolated_cnt == 0) {
2505                         send_changed = true;
2506                 }
2507                 _solo_isolated_cnt++;
2508         } else if (_solo_isolated_cnt > 0) {
2509                 _solo_isolated_cnt--;
2510                 if (_solo_isolated_cnt == 0) {
2511                         send_changed = true;
2512                 }
2513         }
2514
2515         if (send_changed) {
2516                 IsolatedChanged (); /* EMIT SIGNAL */
2517         }
2518 }
2519
2520 void
2521 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2522 {
2523         DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
2524
2525         if (!self_solo_change) {
2526                 // session doesn't care about changes to soloed-by-others
2527                 return;
2528         }
2529
2530         if (solo_update_disabled) {
2531                 // We know already
2532                 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
2533                 return;
2534         }
2535
2536         boost::shared_ptr<Route> route = wpr.lock ();
2537         assert (route);
2538
2539         boost::shared_ptr<RouteList> r = routes.reader ();
2540         int32_t delta;
2541
2542         if (route->self_soloed()) {
2543                 delta = 1;
2544         } else {
2545                 delta = -1;
2546         }
2547
2548         RouteGroup* rg = route->route_group ();
2549         bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
2550
2551         if (delta == 1 && Config->get_exclusive_solo()) {
2552
2553                 /* new solo: disable all other solos, but not the group if its solo-enabled */
2554
2555                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2556                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2557                             (leave_group_alone && ((*i)->route_group() == rg))) {
2558                                 continue;
2559                         }
2560                         (*i)->set_solo (false, this);
2561                 }
2562         }
2563
2564         DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
2565
2566         solo_update_disabled = true;
2567
2568         RouteList uninvolved;
2569
2570         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
2571
2572         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2573                 bool via_sends_only;
2574                 bool in_signal_flow;
2575
2576                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
2577                     (leave_group_alone && ((*i)->route_group() == rg))) {
2578                         continue;
2579                 }
2580
2581                 in_signal_flow = false;
2582
2583                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
2584
2585                 if ((*i)->feeds (route, &via_sends_only)) {
2586                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
2587                         if (!via_sends_only) {
2588                                 if (!route->soloed_by_others_upstream()) {
2589                                         (*i)->mod_solo_by_others_downstream (delta);
2590                                 }
2591                         } else {
2592                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
2593                         }
2594                         in_signal_flow = true;
2595                 } else {
2596                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
2597                 }
2598
2599                 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
2600
2601                 if (route->feeds (*i, &via_sends_only)) {
2602                         /* propagate solo upstream only if routing other than
2603                            sends is involved, but do consider the other route
2604                            (*i) to be part of the signal flow even if only
2605                            sends are involved.
2606                         */
2607                         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
2608                                                                   route->name(),
2609                                                                   (*i)->name(),
2610                                                                   via_sends_only,
2611                                                                   route->soloed_by_others_downstream(),
2612                                                                   route->soloed_by_others_upstream()));
2613                         if (!via_sends_only) {
2614                                 if (!route->soloed_by_others_downstream()) {
2615                                         DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
2616                                         (*i)->mod_solo_by_others_upstream (delta);
2617                                 } else {
2618                                         DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
2619                                 }
2620                         } else {
2621                                 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
2622                         }
2623                         in_signal_flow = true;
2624                 } else {
2625                         DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
2626                 }
2627
2628                 if (!in_signal_flow) {
2629                         uninvolved.push_back (*i);
2630                 }
2631         }
2632
2633         solo_update_disabled = false;
2634         DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
2635
2636         update_route_solo_state (r);
2637
2638         /* now notify that the mute state of the routes not involved in the signal
2639            pathway of the just-solo-changed route may have altered.
2640         */
2641
2642         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2643                 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
2644                 (*i)->mute_changed (this);
2645         }
2646
2647         SoloChanged (); /* EMIT SIGNAL */
2648         set_dirty();
2649 }
2650
2651 void
2652 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2653 {
2654         /* now figure out if anything that matters is soloed (or is "listening")*/
2655
2656         bool something_soloed = false;
2657         uint32_t listeners = 0;
2658         uint32_t isolated = 0;
2659
2660         if (!r) {
2661                 r = routes.reader();
2662         }
2663
2664         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2665                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
2666                         something_soloed = true;
2667                 }
2668
2669                 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
2670                         if (Config->get_solo_control_is_listen_control()) {
2671                                 listeners++;
2672                         } else {
2673                                 (*i)->set_listen (false, this);
2674                         }
2675                 }
2676
2677                 if ((*i)->solo_isolated()) {
2678                         isolated++;
2679                 }
2680         }
2681
2682         if (something_soloed != _non_soloed_outs_muted) {
2683                 _non_soloed_outs_muted = something_soloed;
2684                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2685         }
2686
2687         _listen_cnt = listeners;
2688
2689         if (isolated != _solo_isolated_cnt) {
2690                 _solo_isolated_cnt = isolated;
2691                 IsolatedChanged (); /* EMIT SIGNAL */
2692         }
2693
2694         DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
2695                                                   something_soloed, listeners, isolated));
2696 }
2697
2698 boost::shared_ptr<RouteList>
2699 Session::get_routes_with_internal_returns() const
2700 {
2701         boost::shared_ptr<RouteList> r = routes.reader ();
2702         boost::shared_ptr<RouteList> rl (new RouteList);
2703
2704         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2705                 if ((*i)->internal_return ()) {
2706                         rl->push_back (*i);
2707                 }
2708         }
2709         return rl;
2710 }
2711
2712 bool
2713 Session::io_name_is_legal (const std::string& name)
2714 {
2715         boost::shared_ptr<RouteList> r = routes.reader ();
2716
2717         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2718                 if ((*i)->name() == name) {
2719                         return false;
2720                 }
2721
2722                 if ((*i)->has_io_processor_named (name)) {
2723                         return false;
2724                 }
2725         }
2726
2727         return true;
2728 }
2729
2730 void
2731 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
2732 {
2733         RouteList rl2;
2734         vector<string> connections;
2735
2736         /* if we are passed only a single route and we're not told to turn
2737          * others off, then just do the simple thing.
2738          */
2739
2740         if (flip_others == false && rl->size() == 1) {
2741                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
2742                 if (mt) {
2743                         mt->set_input_active (onoff);
2744                         return;
2745                 }
2746         }
2747
2748         for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
2749
2750                 PortSet& ps ((*rt)->input()->ports());
2751
2752                 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
2753                         p->get_connections (connections);
2754                 }
2755
2756                 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
2757                         routes_using_input_from (*s, rl2);
2758                 }
2759
2760                 /* scan all relevant routes to see if others are on or off */
2761
2762                 bool others_are_already_on = false;
2763
2764                 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2765
2766                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2767
2768                         if (!mt) {
2769                                 continue;
2770                         }
2771
2772                         if ((*r) != (*rt)) {
2773                                 if (mt->input_active()) {
2774                                         others_are_already_on = true;
2775                                 }
2776                         } else {
2777                                 /* this one needs changing */
2778                                 mt->set_input_active (onoff);
2779                         }
2780                 }
2781
2782                 if (flip_others) {
2783
2784                         /* globally reverse other routes */
2785
2786                         for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
2787                                 if ((*r) != (*rt)) {
2788                                         boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
2789                                         if (mt) {
2790                                                 mt->set_input_active (!others_are_already_on);
2791                                         }
2792                                 }
2793                         }
2794                 }
2795         }
2796 }
2797
2798 void
2799 Session::routes_using_input_from (const string& str, RouteList& rl)
2800 {
2801         boost::shared_ptr<RouteList> r = routes.reader();
2802
2803         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2804                 if ((*i)->input()->connected_to (str)) {
2805                         rl.push_back (*i);
2806                 }
2807         }
2808 }
2809
2810 boost::shared_ptr<Route>
2811 Session::route_by_name (string name)
2812 {
2813         boost::shared_ptr<RouteList> r = routes.reader ();
2814
2815         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2816                 if ((*i)->name() == name) {
2817                         return *i;
2818                 }
2819         }
2820
2821         return boost::shared_ptr<Route> ((Route*) 0);
2822 }
2823
2824 boost::shared_ptr<Route>
2825 Session::route_by_id (PBD::ID id)
2826 {
2827         boost::shared_ptr<RouteList> r = routes.reader ();
2828
2829         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2830                 if ((*i)->id() == id) {
2831                         return *i;
2832                 }
2833         }
2834
2835         return boost::shared_ptr<Route> ((Route*) 0);
2836 }
2837
2838 boost::shared_ptr<Track>
2839 Session::track_by_diskstream_id (PBD::ID id)
2840 {
2841         boost::shared_ptr<RouteList> r = routes.reader ();
2842
2843         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2844                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
2845                 if (t && t->using_diskstream_id (id)) {
2846                         return t;
2847                 }
2848         }
2849
2850         return boost::shared_ptr<Track> ();
2851 }
2852
2853 boost::shared_ptr<Route>
2854 Session::route_by_remote_id (uint32_t id)
2855 {
2856         boost::shared_ptr<RouteList> r = routes.reader ();
2857
2858         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2859                 if ((*i)->remote_control_id() == id) {
2860                         return *i;
2861                 }
2862         }
2863
2864         return boost::shared_ptr<Route> ((Route*) 0);
2865 }
2866
2867 void
2868 Session::playlist_region_added (boost::weak_ptr<Region> w)
2869 {
2870         boost::shared_ptr<Region> r = w.lock ();
2871         if (!r) {
2872                 return;
2873         }
2874
2875         /* These are the operations that are currently in progress... */
2876         list<GQuark> curr = _current_trans_quarks;
2877         curr.sort ();
2878
2879         /* ...and these are the operations during which we want to update
2880            the session range location markers.
2881         */
2882         list<GQuark> ops;
2883         ops.push_back (Operations::capture);
2884         ops.push_back (Operations::paste);
2885         ops.push_back (Operations::duplicate_region);
2886         ops.push_back (Operations::insert_file);
2887         ops.push_back (Operations::insert_region);
2888         ops.push_back (Operations::drag_region_brush);
2889         ops.push_back (Operations::region_drag);
2890         ops.push_back (Operations::selection_grab);
2891         ops.push_back (Operations::region_fill);
2892         ops.push_back (Operations::fill_selection);
2893         ops.push_back (Operations::create_region);
2894         ops.push_back (Operations::region_copy);
2895         ops.push_back (Operations::fixed_time_region_copy);
2896         ops.sort ();
2897
2898         /* See if any of the current operations match the ones that we want */
2899         list<GQuark> in;
2900         set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
2901
2902         /* If so, update the session range markers */
2903         if (!in.empty ()) {
2904                 maybe_update_session_range (r->position (), r->last_frame ());
2905         }
2906 }
2907
2908 /** Update the session range markers if a is before the current start or
2909  *  b is after the current end.
2910  */
2911 void
2912 Session::maybe_update_session_range (framepos_t a, framepos_t b)
2913 {
2914         if (_state_of_the_state & Loading) {
2915                 return;
2916         }
2917
2918         if (_session_range_location == 0) {
2919
2920                 add_session_range_location (a, b);
2921
2922         } else {
2923
2924                 if (a < _session_range_location->start()) {
2925                         _session_range_location->set_start (a);
2926                 }
2927
2928                 if (b > _session_range_location->end()) {
2929                         _session_range_location->set_end (b);
2930                 }
2931         }
2932 }
2933
2934 void
2935 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
2936 {
2937         for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2938                 maybe_update_session_range (i->to, i->to + i->length);
2939         }
2940 }
2941
2942 void
2943 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
2944 {
2945         for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
2946                 maybe_update_session_range (i->from, i->to);
2947         }
2948 }
2949
2950 /* Region management */
2951
2952 boost::shared_ptr<Region>
2953 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2954 {
2955         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2956         RegionFactory::RegionMap::const_iterator i;
2957         boost::shared_ptr<Region> region;
2958
2959         Glib::Threads::Mutex::Lock lm (region_lock);
2960
2961         for (i = regions.begin(); i != regions.end(); ++i) {
2962
2963                 region = i->second;
2964
2965                 if (region->whole_file()) {
2966
2967                         if (child->source_equivalent (region)) {
2968                                 return region;
2969                         }
2970                 }
2971         }
2972
2973         return boost::shared_ptr<Region> ();
2974 }
2975
2976 int
2977 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2978 {
2979         set<boost::shared_ptr<Region> > relevant_regions;
2980
2981         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2982                 RegionFactory::get_regions_using_source (*s, relevant_regions);
2983         }
2984
2985         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2986                 set<boost::shared_ptr<Region> >::iterator tmp;
2987
2988                 tmp = r;
2989                 ++tmp;
2990
2991                 playlists->destroy_region (*r);
2992                 RegionFactory::map_remove (*r);
2993
2994                 (*r)->drop_sources ();
2995                 (*r)->drop_references ();
2996
2997                 relevant_regions.erase (r);
2998
2999                 r = tmp;
3000         }
3001
3002         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3003
3004                 {
3005                         Glib::Threads::Mutex::Lock ls (source_lock);
3006                         /* remove from the main source list */
3007                         sources.erase ((*s)->id());
3008                 }
3009
3010                 (*s)->mark_for_remove ();
3011                 (*s)->drop_references ();
3012
3013                 s = srcs.erase (s);
3014         }
3015
3016         return 0;
3017 }
3018
3019 int
3020 Session::remove_last_capture ()
3021 {
3022         list<boost::shared_ptr<Source> > srcs;
3023
3024         boost::shared_ptr<RouteList> rl = routes.reader ();
3025         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3026                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3027                 if (!tr) {
3028                         continue;
3029                 }
3030
3031                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3032
3033                 if (!l.empty()) {
3034                         srcs.insert (srcs.end(), l.begin(), l.end());
3035                         l.clear ();
3036                 }
3037         }
3038
3039         destroy_sources (srcs);
3040
3041         save_state (_current_snapshot_name);
3042
3043         return 0;
3044 }
3045
3046 /* Source Management */
3047
3048 void
3049 Session::add_source (boost::shared_ptr<Source> source)
3050 {
3051         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3052         pair<SourceMap::iterator,bool> result;
3053
3054         entry.first = source->id();
3055         entry.second = source;
3056
3057         {
3058                 Glib::Threads::Mutex::Lock lm (source_lock);
3059                 result = sources.insert (entry);
3060         }
3061
3062         if (result.second) {
3063
3064                 /* yay, new source */
3065
3066                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3067
3068                 if (fs) {
3069                         if (!fs->within_session()) {
3070                                 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3071                         }
3072                 }
3073
3074                 set_dirty();
3075
3076                 boost::shared_ptr<AudioFileSource> afs;
3077
3078                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3079                         if (Config->get_auto_analyse_audio()) {
3080                                 Analyser::queue_source_for_analysis (source, false);
3081                         }
3082                 }
3083
3084                 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3085         }
3086 }
3087
3088 void
3089 Session::remove_source (boost::weak_ptr<Source> src)
3090 {
3091         if (_state_of_the_state & Deletion) {
3092                 return;
3093         }
3094
3095         SourceMap::iterator i;
3096         boost::shared_ptr<Source> source = src.lock();
3097
3098         if (!source) {
3099                 return;
3100         }
3101
3102         {
3103                 Glib::Threads::Mutex::Lock lm (source_lock);
3104
3105                 if ((i = sources.find (source->id())) != sources.end()) {
3106                         sources.erase (i);
3107                 }
3108         }
3109
3110         if (!(_state_of_the_state & InCleanup)) {
3111
3112                 /* save state so we don't end up with a session file
3113                    referring to non-existent sources.
3114                 */
3115
3116                 save_state (_current_snapshot_name);
3117         }
3118 }
3119
3120 boost::shared_ptr<Source>
3121 Session::source_by_id (const PBD::ID& id)
3122 {
3123         Glib::Threads::Mutex::Lock lm (source_lock);
3124         SourceMap::iterator i;
3125         boost::shared_ptr<Source> source;
3126
3127         if ((i = sources.find (id)) != sources.end()) {
3128                 source = i->second;
3129         }
3130
3131         return source;
3132 }
3133
3134 boost::shared_ptr<Source>
3135 Session::source_by_path_and_channel (const string& path, uint16_t chn)
3136 {
3137         Glib::Threads::Mutex::Lock lm (source_lock);
3138
3139         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3140                 boost::shared_ptr<AudioFileSource> afs
3141                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3142
3143                 if (afs && afs->path() == path && chn == afs->channel()) {
3144                         return afs;
3145                 }
3146         }
3147         return boost::shared_ptr<Source>();
3148 }
3149
3150 uint32_t
3151 Session::count_sources_by_origin (const string& path)
3152 {
3153         uint32_t cnt = 0;
3154         Glib::Threads::Mutex::Lock lm (source_lock);
3155
3156         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3157                 boost::shared_ptr<FileSource> fs
3158                         = boost::dynamic_pointer_cast<FileSource>(i->second);
3159
3160                 if (fs && fs->origin() == path) {
3161                         ++cnt;
3162                 }
3163         }
3164
3165         return cnt;
3166 }
3167
3168
3169 string
3170 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
3171 {
3172         string look_for;
3173         string old_basename = PBD::basename_nosuffix (oldname);
3174         string new_legalized = legalize_for_path (newname);
3175
3176         /* note: we know (or assume) the old path is already valid */
3177
3178         if (destructive) {
3179
3180                 /* destructive file sources have a name of the form:
3181
3182                     /path/to/Tnnnn-NAME(%[LR])?.wav
3183
3184                     the task here is to replace NAME with the new name.
3185                 */
3186
3187                 string dir;
3188                 string prefix;
3189                 string::size_type dash;
3190
3191                 dir = Glib::path_get_dirname (path);
3192                 path = Glib::path_get_basename (path);
3193
3194                 /* '-' is not a legal character for the NAME part of the path */
3195
3196                 if ((dash = path.find_last_of ('-')) == string::npos) {
3197                         return "";
3198                 }
3199
3200                 prefix = path.substr (0, dash);
3201
3202                 path += prefix;
3203                 path += '-';
3204                 path += new_legalized;
3205                 path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3206                 path = Glib::build_filename (dir, path);
3207
3208         } else {
3209
3210                 /* non-destructive file sources have a name of the form:
3211
3212                     /path/to/NAME-nnnnn(%[LR])?.ext
3213
3214                     the task here is to replace NAME with the new name.
3215                 */
3216
3217                 string dir;
3218                 string suffix;
3219                 string::size_type dash;
3220                 string::size_type postfix;
3221
3222                 dir = Glib::path_get_dirname (path);
3223                 path = Glib::path_get_basename (path);
3224
3225                 /* '-' is not a legal character for the NAME part of the path */
3226
3227                 if ((dash = path.find_last_of ('-')) == string::npos) {
3228                         return "";
3229                 }
3230
3231                 suffix = path.substr (dash+1);
3232
3233                 // Suffix is now everything after the dash. Now we need to eliminate
3234                 // the nnnnn part, which is done by either finding a '%' or a '.'
3235
3236                 postfix = suffix.find_last_of ("%");
3237                 if (postfix == string::npos) {
3238                         postfix = suffix.find_last_of ('.');
3239                 }
3240
3241                 if (postfix != string::npos) {
3242                         suffix = suffix.substr (postfix);
3243                 } else {
3244                         error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
3245                         return "";
3246                 }
3247
3248                 const uint32_t limit = 10000;
3249                 char buf[PATH_MAX+1];
3250
3251                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3252
3253                         snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
3254
3255                         if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
3256                                 path = Glib::build_filename (dir, buf);
3257                                 break;
3258                         }
3259
3260                         path = "";
3261                 }
3262
3263                 if (path.empty()) {
3264                         fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
3265                                                  newname) << endl;
3266                         /*NOTREACHED*/
3267                 }
3268         }
3269
3270         return path;
3271 }
3272
3273 /** Return the full path (in some session directory) for a new within-session source.
3274  * \a name must be a session-unique name that does not contain slashes
3275  *         (e.g. as returned by new_*_source_name)
3276  */
3277 string
3278 Session::new_source_path_from_name (DataType type, const string& name)
3279 {
3280         assert(name.find("/") == string::npos);
3281
3282         SessionDirectory sdir(get_best_session_directory_for_new_source());
3283
3284         std::string p;
3285         if (type == DataType::AUDIO) {
3286                 p = sdir.sound_path();
3287         } else if (type == DataType::MIDI) {
3288                 p = sdir.midi_path();
3289         } else {
3290                 error << "Unknown source type, unable to create file path" << endmsg;
3291                 return "";
3292         }
3293
3294         return Glib::build_filename (p, name);
3295 }
3296
3297 string
3298 Session::peak_path (string base) const
3299 {
3300         return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
3301 }
3302
3303 /** Return a unique name based on \a base for a new internal audio source */
3304 string
3305 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
3306 {
3307         uint32_t cnt;
3308         char buf[PATH_MAX+1];
3309         const uint32_t limit = 10000;
3310         string legalized;
3311         string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
3312
3313         buf[0] = '\0';
3314         legalized = legalize_for_path (base);
3315
3316         // Find a "version" of the base name that doesn't exist in any of the possible directories.
3317         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3318
3319                 vector<space_and_path>::iterator i;
3320                 uint32_t existing = 0;
3321
3322                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3323
3324                         if (destructive) {
3325
3326                                 if (nchan < 2) {
3327                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3328                                                   cnt, legalized.c_str(), ext.c_str());
3329                                 } else if (nchan == 2) {
3330                                         if (chan == 0) {
3331                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
3332                                                           cnt, legalized.c_str(), ext.c_str());
3333                                         } else {
3334                                                 snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
3335                                                           cnt, legalized.c_str(), ext.c_str());
3336                                         }
3337                                 } else if (nchan < 26) {
3338                                         snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
3339                                                   cnt, legalized.c_str(), 'a' + chan, ext.c_str());
3340                                 } else {
3341                                         snprintf (buf, sizeof(buf), "T%04d-%s%s",
3342                                                   cnt, legalized.c_str(), ext.c_str());
3343                                 }
3344
3345                         } else {
3346
3347                                 if (nchan < 2) {
3348                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3349                                 } else if (nchan == 2) {
3350                                         if (chan == 0) {
3351                                                 snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
3352                                         } else {
3353                                                 snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
3354                                         }
3355                                 } else if (nchan < 26) {
3356                                         snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
3357                                 } else {
3358                                         snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
3359                                 }
3360                         }
3361
3362                         SessionDirectory sdir((*i).path);
3363
3364                         string spath = sdir.sound_path();
3365
3366                         /* note that we search *without* the extension so that
3367                            we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
3368                            in the event that this new name is required for
3369                            a file format change.
3370                         */
3371
3372                         if (matching_unsuffixed_filename_exists_in (spath, buf)) {
3373                                 existing++;
3374                                 break;
3375                         }
3376                 }
3377
3378                 if (existing == 0) {
3379                         break;
3380                 }
3381
3382                 if (cnt > limit) {
3383                         error << string_compose(
3384                                         _("There are already %1 recordings for %2, which I consider too many."),
3385                                         limit, base) << endmsg;
3386                         destroy ();
3387                         throw failed_constructor();
3388                 }
3389         }
3390
3391         return Glib::path_get_basename (buf);
3392 }
3393
3394 /** Create a new within-session audio source */
3395 boost::shared_ptr<AudioFileSource>
3396 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
3397 {
3398         const string name    = new_audio_source_name (n, n_chans, chan, destructive);
3399         const string path    = new_source_path_from_name(DataType::AUDIO, name);
3400
3401         return boost::dynamic_pointer_cast<AudioFileSource> (
3402                 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
3403 }
3404
3405 /** Return a unique name based on \a base for a new internal MIDI source */
3406 string
3407 Session::new_midi_source_name (const string& base)
3408 {
3409         uint32_t cnt;
3410         char buf[PATH_MAX+1];
3411         const uint32_t limit = 10000;
3412         string legalized;
3413
3414         buf[0] = '\0';
3415         legalized = legalize_for_path (base);
3416
3417         // Find a "version" of the file name that doesn't exist in any of the possible directories.
3418         for (cnt = 1; cnt <= limit; ++cnt) {
3419
3420                 vector<space_and_path>::iterator i;
3421                 uint32_t existing = 0;
3422
3423                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3424
3425                         SessionDirectory sdir((*i).path);
3426
3427                         std::string p = Glib::build_filename (sdir.midi_path(), legalized);
3428
3429                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
3430
3431                         if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
3432                                 existing++;
3433                         }
3434                 }
3435
3436                 if (existing == 0) {
3437                         break;
3438                 }
3439
3440                 if (cnt > limit) {
3441                         error << string_compose(
3442                                         _("There are already %1 recordings for %2, which I consider too many."),
3443                                         limit, base) << endmsg;
3444                         destroy ();
3445                         throw failed_constructor();
3446                 }
3447         }
3448
3449         return Glib::path_get_basename(buf);
3450 }
3451
3452
3453 /** Create a new within-session MIDI source */
3454 boost::shared_ptr<MidiSource>
3455 Session::create_midi_source_for_session (Track* track, string const & n)
3456 {
3457         /* try to use the existing write source for the track, to keep numbering sane
3458          */
3459
3460         if (track) {
3461                 /*MidiTrack* mt = dynamic_cast<Track*> (track);
3462                   assert (mt);
3463                 */
3464
3465                 list<boost::shared_ptr<Source> > l = track->steal_write_sources ();
3466
3467                 if (!l.empty()) {
3468                         assert (boost::dynamic_pointer_cast<MidiSource> (l.front()));
3469                         return boost::dynamic_pointer_cast<MidiSource> (l.front());
3470                 }
3471         }
3472
3473         const string name = new_midi_source_name (n);
3474         const string path = new_source_path_from_name (DataType::MIDI, name);
3475
3476         return boost::dynamic_pointer_cast<SMFSource> (
3477                 SourceFactory::createWritable (
3478                         DataType::MIDI, *this, path, false, frame_rate()));
3479 }
3480
3481
3482 void
3483 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
3484 {
3485         if (playlist->hidden()) {
3486                 return;
3487         }
3488
3489         playlists->add (playlist);
3490
3491         if (unused) {
3492                 playlist->release();
3493         }
3494
3495         set_dirty();
3496 }
3497
3498 void
3499 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3500 {
3501         if (_state_of_the_state & Deletion) {
3502                 return;
3503         }
3504
3505         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3506
3507         if (!playlist) {
3508                 return;
3509         }
3510
3511         playlists->remove (playlist);
3512
3513         set_dirty();
3514 }
3515
3516 void
3517 Session::set_audition (boost::shared_ptr<Region> r)
3518 {
3519         pending_audition_region = r;
3520         add_post_transport_work (PostTransportAudition);
3521         _butler->schedule_transport_work ();
3522 }
3523
3524 void
3525 Session::audition_playlist ()
3526 {
3527         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3528         ev->region.reset ();
3529         queue_event (ev);
3530 }
3531
3532 void
3533 Session::non_realtime_set_audition ()
3534 {
3535         assert (pending_audition_region);
3536         auditioner->audition_region (pending_audition_region);
3537         pending_audition_region.reset ();
3538         AuditionActive (true); /* EMIT SIGNAL */
3539 }
3540
3541 void
3542 Session::audition_region (boost::shared_ptr<Region> r)
3543 {
3544         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3545         ev->region = r;
3546         queue_event (ev);
3547 }
3548
3549 void
3550 Session::cancel_audition ()
3551 {
3552         if (auditioner->auditioning()) {
3553                 auditioner->cancel_audition ();
3554                 AuditionActive (false); /* EMIT SIGNAL */
3555         }
3556 }
3557
3558 bool
3559 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3560 {
3561         if (a->is_monitor()) {
3562                 return true;
3563         }
3564         if (b->is_monitor()) {
3565                 return false;
3566         }
3567         return a->order_key (MixerSort) < b->order_key (MixerSort);
3568 }
3569
3570 bool
3571 Session::is_auditioning () const
3572 {
3573         /* can be called before we have an auditioner object */
3574         if (auditioner) {
3575                 return auditioner->auditioning();
3576         } else {
3577                 return false;
3578         }
3579 }
3580
3581 void
3582 Session::graph_reordered ()
3583 {
3584         /* don't do this stuff if we are setting up connections
3585            from a set_state() call or creating new tracks. Ditto for deletion.
3586         */
3587
3588         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
3589                 return;
3590         }
3591
3592         /* every track/bus asked for this to be handled but it was deferred because
3593            we were connecting. do it now.
3594         */
3595
3596         request_input_change_handling ();
3597
3598         resort_routes ();
3599
3600         /* force all diskstreams to update their capture offset values to
3601            reflect any changes in latencies within the graph.
3602         */
3603
3604         boost::shared_ptr<RouteList> rl = routes.reader ();
3605         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3606                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3607                 if (tr) {
3608                         tr->set_capture_offset ();
3609                 }
3610         }
3611 }
3612
3613 /** @return Number of frames that there is disk space available to write,
3614  *  if known.
3615  */
3616 boost::optional<framecnt_t>
3617 Session::available_capture_duration ()
3618 {
3619         Glib::Threads::Mutex::Lock lm (space_lock);
3620
3621         if (_total_free_4k_blocks_uncertain) {
3622                 return boost::optional<framecnt_t> ();
3623         }
3624
3625         float sample_bytes_on_disk = 4.0; // keep gcc happy
3626
3627         switch (config.get_native_file_data_format()) {
3628         case FormatFloat:
3629                 sample_bytes_on_disk = 4.0;
3630                 break;
3631
3632         case FormatInt24:
3633                 sample_bytes_on_disk = 3.0;
3634                 break;
3635
3636         case FormatInt16:
3637                 sample_bytes_on_disk = 2.0;
3638                 break;
3639
3640         default:
3641                 /* impossible, but keep some gcc versions happy */
3642                 fatal << string_compose (_("programming error: %1"),
3643                                          X_("illegal native file data format"))
3644                       << endmsg;
3645                 /*NOTREACHED*/
3646         }
3647
3648         double scale = 4096.0 / sample_bytes_on_disk;
3649
3650         if (_total_free_4k_blocks * scale > (double) max_framecnt) {
3651                 return max_framecnt;
3652         }
3653
3654         return (framecnt_t) floor (_total_free_4k_blocks * scale);
3655 }
3656
3657 void
3658 Session::add_bundle (boost::shared_ptr<Bundle> bundle)
3659 {
3660         {
3661                 RCUWriter<BundleList> writer (_bundles);
3662                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3663                 b->push_back (bundle);
3664         }
3665
3666         BundleAdded (bundle); /* EMIT SIGNAL */
3667
3668         set_dirty();
3669 }
3670
3671 void
3672 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
3673 {
3674         bool removed = false;
3675
3676         {
3677                 RCUWriter<BundleList> writer (_bundles);
3678                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3679                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3680
3681                 if (i != b->end()) {
3682                         b->erase (i);
3683                         removed = true;
3684                 }
3685         }
3686
3687         if (removed) {
3688                  BundleRemoved (bundle); /* EMIT SIGNAL */
3689         }
3690
3691         set_dirty();
3692 }
3693
3694 boost::shared_ptr<Bundle>
3695 Session::bundle_by_name (string name) const
3696 {
3697         boost::shared_ptr<BundleList> b = _bundles.reader ();
3698
3699         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3700                 if ((*i)->name() == name) {
3701                         return* i;
3702                 }
3703         }
3704
3705         return boost::shared_ptr<Bundle> ();
3706 }
3707
3708 void
3709 Session::tempo_map_changed (const PropertyChange&)
3710 {
3711         clear_clicks ();
3712
3713         playlists->update_after_tempo_map_change ();
3714
3715         _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
3716
3717         set_dirty ();
3718 }
3719
3720 void
3721 Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
3722 {
3723         for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
3724                 (*i)->recompute_frames_from_bbt ();
3725         }
3726 }
3727
3728 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3729  * the given count with the current block size.
3730  */
3731 void
3732 Session::ensure_buffers (ChanCount howmany)
3733 {
3734         BufferManager::ensure_buffers (howmany);
3735 }
3736
3737 void
3738 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3739 {
3740         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3741                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3742         }
3743 }
3744
3745 uint32_t
3746 Session::next_insert_id ()
3747 {
3748         /* this doesn't really loop forever. just think about it */
3749
3750         while (true) {
3751                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3752                         if (!insert_bitset[n]) {
3753                                 insert_bitset[n] = true;
3754                                 return n;
3755
3756                         }
3757                 }
3758
3759                 /* none available, so resize and try again */
3760
3761                 insert_bitset.resize (insert_bitset.size() + 16, false);
3762         }
3763 }
3764
3765 uint32_t
3766 Session::next_send_id ()
3767 {
3768         /* this doesn't really loop forever. just think about it */
3769
3770         while (true) {
3771                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3772                         if (!send_bitset[n]) {
3773                                 send_bitset[n] = true;
3774                                 return n;
3775
3776                         }
3777                 }
3778
3779                 /* none available, so resize and try again */
3780
3781                 send_bitset.resize (send_bitset.size() + 16, false);
3782         }
3783 }
3784
3785 uint32_t
3786 Session::next_aux_send_id ()
3787 {
3788         /* this doesn't really loop forever. just think about it */
3789
3790         while (true) {
3791                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
3792                         if (!aux_send_bitset[n]) {
3793                                 aux_send_bitset[n] = true;
3794                                 return n;
3795
3796                         }
3797                 }
3798
3799                 /* none available, so resize and try again */
3800
3801                 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
3802         }
3803 }
3804
3805 uint32_t
3806 Session::next_return_id ()
3807 {
3808         /* this doesn't really loop forever. just think about it */
3809
3810         while (true) {
3811                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3812                         if (!return_bitset[n]) {
3813                                 return_bitset[n] = true;
3814                                 return n;
3815
3816                         }
3817                 }
3818
3819                 /* none available, so resize and try again */
3820
3821                 return_bitset.resize (return_bitset.size() + 16, false);
3822         }
3823 }
3824
3825 void
3826 Session::mark_send_id (uint32_t id)
3827 {
3828         if (id >= send_bitset.size()) {
3829                 send_bitset.resize (id+16, false);
3830         }
3831         if (send_bitset[id]) {
3832                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3833         }
3834         send_bitset[id] = true;
3835 }
3836
3837 void
3838 Session::mark_aux_send_id (uint32_t id)
3839 {
3840         if (id >= aux_send_bitset.size()) {
3841                 aux_send_bitset.resize (id+16, false);
3842         }
3843         if (aux_send_bitset[id]) {
3844                 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
3845         }
3846         aux_send_bitset[id] = true;
3847 }
3848
3849 void
3850 Session::mark_return_id (uint32_t id)
3851 {
3852         if (id >= return_bitset.size()) {
3853                 return_bitset.resize (id+16, false);
3854         }
3855         if (return_bitset[id]) {
3856                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3857         }
3858         return_bitset[id] = true;
3859 }
3860
3861 void
3862 Session::mark_insert_id (uint32_t id)
3863 {
3864         if (id >= insert_bitset.size()) {
3865                 insert_bitset.resize (id+16, false);
3866         }
3867         if (insert_bitset[id]) {
3868                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3869         }
3870         insert_bitset[id] = true;
3871 }
3872
3873 void
3874 Session::unmark_send_id (uint32_t id)
3875 {
3876         if (id < send_bitset.size()) {
3877                 send_bitset[id] = false;
3878         }
3879 }
3880
3881 void
3882 Session::unmark_aux_send_id (uint32_t id)
3883 {
3884         if (id < aux_send_bitset.size()) {
3885                 aux_send_bitset[id] = false;
3886         }
3887 }
3888
3889 void
3890 Session::unmark_return_id (uint32_t id)
3891 {
3892         if (id < return_bitset.size()) {
3893                 return_bitset[id] = false;
3894         }
3895 }
3896
3897 void
3898 Session::unmark_insert_id (uint32_t id)
3899 {
3900         if (id < insert_bitset.size()) {
3901                 insert_bitset[id] = false;
3902         }
3903 }
3904
3905 void
3906 Session::reset_native_file_format ()
3907 {
3908         boost::shared_ptr<RouteList> rl = routes.reader ();
3909         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3910                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3911                 if (tr) {
3912                         /* don't save state as we do this, there's no point
3913                          */
3914
3915                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
3916                         tr->reset_write_sources (false);
3917                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
3918                 }
3919         }
3920 }
3921
3922 bool
3923 Session::route_name_unique (string n) const
3924 {
3925         boost::shared_ptr<RouteList> r = routes.reader ();
3926
3927         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3928                 if ((*i)->name() == n) {
3929                         return false;
3930                 }
3931         }
3932
3933         return true;
3934 }
3935
3936 bool
3937 Session::route_name_internal (string n) const
3938 {
3939         if (auditioner && auditioner->name() == n) {
3940                 return true;
3941         }
3942
3943         if (_click_io && _click_io->name() == n) {
3944                 return true;
3945         }
3946
3947         return false;
3948 }
3949
3950 int
3951 Session::freeze_all (InterThreadInfo& itt)
3952 {
3953         boost::shared_ptr<RouteList> r = routes.reader ();
3954
3955         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3956
3957                 boost::shared_ptr<Track> t;
3958
3959                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3960                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3961                            of every track.
3962                         */
3963                         t->freeze_me (itt);
3964                 }
3965         }
3966
3967         return 0;
3968 }
3969
3970 boost::shared_ptr<Region>
3971 Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
3972                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3973                           InterThreadInfo& itt,
3974                           boost::shared_ptr<Processor> endpoint, bool include_endpoint,
3975                           bool for_export)
3976 {
3977         boost::shared_ptr<Region> result;
3978         boost::shared_ptr<Playlist> playlist;
3979         boost::shared_ptr<AudioFileSource> fsource;
3980         uint32_t x;
3981         char buf[PATH_MAX+1];
3982         ChanCount diskstream_channels (track.n_channels());
3983         framepos_t position;
3984         framecnt_t this_chunk;
3985         framepos_t to_do;
3986         BufferSet buffers;
3987         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3988         const string sound_dir = sdir.sound_path();
3989         framepos_t len = end - start;
3990         bool need_block_size_reset = false;
3991         string ext;
3992         ChanCount const max_proc = track.max_processor_streams ();
3993
3994         if (end <= start) {
3995                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3996                                          end, start) << endmsg;
3997                 return result;
3998         }
3999
4000         const framecnt_t chunk_size = (256 * 1024)/4;
4001
4002         // block all process callback handling
4003
4004         block_processing ();
4005
4006         /* call tree *MUST* hold route_lock */
4007
4008         if ((playlist = track.playlist()) == 0) {
4009                 goto out;
4010         }
4011
4012         ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4013
4014         for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
4015
4016                 for (x = 0; x < 99999; ++x) {
4017                         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());
4018                         if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
4019                                 break;
4020                         }
4021                 }
4022
4023                 if (x == 99999) {
4024                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4025                         goto out;
4026                 }
4027
4028                 try {
4029                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4030                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4031                 }
4032
4033                 catch (failed_constructor& err) {
4034                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4035                         goto out;
4036                 }
4037
4038                 srcs.push_back (fsource);
4039         }
4040
4041         /* tell redirects that care that we are about to use a much larger
4042          * blocksize. this will flush all plugins too, so that they are ready
4043          * to be used for this process.
4044          */
4045
4046         need_block_size_reset = true;
4047         track.set_block_size (chunk_size);
4048
4049         position = start;
4050         to_do = len;
4051
4052         /* create a set of reasonably-sized buffers */
4053         buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
4054         buffers.set_count (max_proc);
4055
4056         for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4057                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4058                 if (afs)
4059                         afs->prepare_for_peakfile_writes ();
4060         }
4061
4062         while (to_do && !itt.cancel) {
4063
4064                 this_chunk = min (to_do, chunk_size);
4065
4066                 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export)) {
4067                         goto out;
4068                 }
4069
4070                 uint32_t n = 0;
4071                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4072                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4073
4074                         if (afs) {
4075                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4076                                         goto out;
4077                                 }
4078                         }
4079                 }
4080
4081                 start += this_chunk;
4082                 to_do -= this_chunk;
4083
4084                 itt.progress = (float) (1.0 - ((double) to_do / len));
4085
4086         }
4087
4088         if (!itt.cancel) {
4089
4090                 time_t now;
4091                 struct tm* xnow;
4092                 time (&now);
4093                 xnow = localtime (&now);
4094
4095                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4096                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4097
4098                         if (afs) {
4099                                 afs->update_header (position, *xnow, now);
4100                                 afs->flush_header ();
4101                         }
4102                 }
4103
4104                 /* construct a region to represent the bounced material */
4105
4106                 PropertyList plist;
4107
4108                 plist.add (Properties::start, 0);
4109                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
4110                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
4111
4112                 result = RegionFactory::create (srcs, plist);
4113
4114         }
4115
4116   out:
4117         if (!result) {
4118                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4119                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4120
4121                         if (afs) {
4122                                 afs->mark_for_remove ();
4123                         }
4124
4125                         (*src)->drop_references ();
4126                 }
4127
4128         } else {
4129                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4130                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4131
4132                         if (afs)
4133                                 afs->done_with_peakfile_writes ();
4134                 }
4135         }
4136
4137
4138         if (need_block_size_reset) {
4139                 track.set_block_size (get_block_size());
4140         }
4141
4142         unblock_processing ();
4143
4144         return result;
4145 }
4146
4147 gain_t*
4148 Session::gain_automation_buffer() const
4149 {
4150         return ProcessThread::gain_automation_buffer ();
4151 }
4152
4153 gain_t*
4154 Session::send_gain_automation_buffer() const
4155 {
4156         return ProcessThread::send_gain_automation_buffer ();
4157 }
4158
4159 pan_t**
4160 Session::pan_automation_buffer() const
4161 {
4162         return ProcessThread::pan_automation_buffer ();
4163 }
4164
4165 BufferSet&
4166 Session::get_silent_buffers (ChanCount count)
4167 {
4168         return ProcessThread::get_silent_buffers (count);
4169 }
4170
4171 BufferSet&
4172 Session::get_scratch_buffers (ChanCount count)
4173 {
4174         return ProcessThread::get_scratch_buffers (count);
4175 }
4176
4177 BufferSet&
4178 Session::get_mix_buffers (ChanCount count)
4179 {
4180         return ProcessThread::get_mix_buffers (count);
4181 }
4182
4183 uint32_t
4184 Session::ntracks () const
4185 {
4186         uint32_t n = 0;
4187         boost::shared_ptr<RouteList> r = routes.reader ();
4188
4189         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4190                 if (boost::dynamic_pointer_cast<Track> (*i)) {
4191                         ++n;
4192                 }
4193         }
4194
4195         return n;
4196 }
4197
4198 uint32_t
4199 Session::nbusses () const
4200 {
4201         uint32_t n = 0;
4202         boost::shared_ptr<RouteList> r = routes.reader ();
4203
4204         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4205                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
4206                         ++n;
4207                 }
4208         }
4209
4210         return n;
4211 }
4212
4213 void
4214 Session::add_automation_list(AutomationList *al)
4215 {
4216         automation_lists[al->id()] = al;
4217 }
4218
4219 /** @return true if there is at least one record-enabled track, otherwise false */
4220 bool
4221 Session::have_rec_enabled_track () const
4222 {
4223         return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
4224 }
4225
4226 /** Update the state of our rec-enabled tracks flag */
4227 void
4228 Session::update_have_rec_enabled_track ()
4229 {
4230         boost::shared_ptr<RouteList> rl = routes.reader ();
4231         RouteList::iterator i = rl->begin();
4232         while (i != rl->end ()) {
4233
4234                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4235                 if (tr && tr->record_enabled ()) {
4236                         break;
4237                 }
4238
4239                 ++i;
4240         }
4241
4242         int const old = g_atomic_int_get (&_have_rec_enabled_track);
4243
4244         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
4245
4246         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
4247                 RecordStateChanged (); /* EMIT SIGNAL */
4248         }
4249 }
4250
4251 void
4252 Session::listen_position_changed ()
4253 {
4254         boost::shared_ptr<RouteList> r = routes.reader ();
4255
4256         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4257                 (*i)->listen_position_changed ();
4258         }
4259 }
4260
4261 void
4262 Session::solo_control_mode_changed ()
4263 {
4264         /* cancel all solo or all listen when solo control mode changes */
4265
4266         if (soloing()) {
4267                 set_solo (get_routes(), false);
4268         } else if (listening()) {
4269                 set_listen (get_routes(), false);
4270         }
4271 }
4272
4273 /** Called when a property of one of our route groups changes */
4274 void
4275 Session::route_group_property_changed (RouteGroup* rg)
4276 {
4277         RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
4278 }
4279
4280 /** Called when a route is added to one of our route groups */
4281 void
4282 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4283 {
4284         RouteAddedToRouteGroup (rg, r);
4285 }
4286
4287 /** Called when a route is removed from one of our route groups */
4288 void
4289 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
4290 {
4291         RouteRemovedFromRouteGroup (rg, r);
4292 }
4293
4294 boost::shared_ptr<RouteList>
4295 Session::get_routes_with_regions_at (framepos_t const p) const
4296 {
4297         boost::shared_ptr<RouteList> r = routes.reader ();
4298         boost::shared_ptr<RouteList> rl (new RouteList);
4299
4300         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4301                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4302                 if (!tr) {
4303                         continue;
4304                 }
4305
4306                 boost::shared_ptr<Playlist> pl = tr->playlist ();
4307                 if (!pl) {
4308                         continue;
4309                 }
4310
4311                 if (pl->has_region_at (p)) {
4312                         rl->push_back (*i);
4313                 }
4314         }
4315
4316         return rl;
4317 }
4318
4319 void
4320 Session::goto_end ()
4321 {
4322         if (_session_range_location) {
4323                 request_locate (_session_range_location->end(), false);
4324         } else {
4325                 request_locate (0, false);
4326         }
4327 }
4328
4329 void
4330 Session::goto_start ()
4331 {
4332         if (_session_range_location) {
4333                 request_locate (_session_range_location->start(), false);
4334         } else {
4335                 request_locate (0, false);
4336         }
4337 }
4338
4339 framepos_t
4340 Session::current_start_frame () const
4341 {
4342         return _session_range_location ? _session_range_location->start() : 0;
4343 }
4344
4345 framepos_t
4346 Session::current_end_frame () const
4347 {
4348         return _session_range_location ? _session_range_location->end() : 0;
4349 }
4350
4351 void
4352 Session::add_session_range_location (framepos_t start, framepos_t end)
4353 {
4354         _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
4355         _locations->add (_session_range_location);
4356 }
4357
4358 void
4359 Session::step_edit_status_change (bool yn)
4360 {
4361         bool send = false;
4362
4363         bool val = false;
4364         if (yn) {
4365                 send = (_step_editors == 0);
4366                 val = true;
4367
4368                 _step_editors++;
4369         } else {
4370                 send = (_step_editors == 1);
4371                 val = false;
4372
4373                 if (_step_editors > 0) {
4374                         _step_editors--;
4375                 }
4376         }
4377
4378         if (send) {
4379                 StepEditStatusChange (val);
4380         }
4381 }
4382
4383
4384 void
4385 Session::start_time_changed (framepos_t old)
4386 {
4387         /* Update the auto loop range to match the session range
4388            (unless the auto loop range has been changed by the user)
4389         */
4390
4391         Location* s = _locations->session_range_location ();
4392         if (s == 0) {
4393                 return;
4394         }
4395
4396         Location* l = _locations->auto_loop_location ();
4397
4398         if (l && l->start() == old) {
4399                 l->set_start (s->start(), true);
4400         }
4401 }
4402
4403 void
4404 Session::end_time_changed (framepos_t old)
4405 {
4406         /* Update the auto loop range to match the session range
4407            (unless the auto loop range has been changed by the user)
4408         */
4409
4410         Location* s = _locations->session_range_location ();
4411         if (s == 0) {
4412                 return;
4413         }
4414
4415         Location* l = _locations->auto_loop_location ();
4416
4417         if (l && l->end() == old) {
4418                 l->set_end (s->end(), true);
4419         }
4420 }
4421
4422 string
4423 Session::source_search_path (DataType type) const
4424 {
4425         vector<string> s;
4426
4427         if (session_dirs.size() == 1) {
4428                 switch (type) {
4429                 case DataType::AUDIO:
4430                         s.push_back (_session_dir->sound_path());
4431                         break;
4432                 case DataType::MIDI:
4433                         s.push_back (_session_dir->midi_path());
4434                         break;
4435                 }
4436         } else {
4437                 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4438                         SessionDirectory sdir (i->path);
4439                         switch (type) {
4440                         case DataType::AUDIO:
4441                                 s.push_back (sdir.sound_path());
4442                                 break;
4443                         case DataType::MIDI:
4444                                 s.push_back (sdir.midi_path());
4445                                 break;
4446                         }
4447                 }
4448         }
4449
4450         if (type == DataType::AUDIO) {
4451                 const string sound_path_2X = _session_dir->sound_path_2X();
4452                 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
4453                         if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
4454                                 s.push_back (sound_path_2X);
4455                         }
4456                 }
4457         }
4458
4459         /* now check the explicit (possibly user-specified) search path
4460          */
4461
4462         vector<string> dirs;
4463
4464         switch (type) {
4465         case DataType::AUDIO:
4466                 split (config.get_audio_search_path (), dirs, ':');
4467                 break;
4468         case DataType::MIDI:
4469                 split (config.get_midi_search_path (), dirs, ':');
4470                 break;
4471         }
4472
4473         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4474                 if (find (s.begin(), s.end(), *i) == s.end()) {
4475                         s.push_back (*i);
4476                 }
4477         }
4478
4479         string search_path;
4480
4481         for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
4482                 if (!search_path.empty()) {
4483                         search_path += ':';
4484                 }
4485                 search_path += *si;
4486         }
4487
4488         return search_path;
4489 }
4490
4491 void
4492 Session::ensure_search_path_includes (const string& path, DataType type)
4493 {
4494         string search_path;
4495         vector<string> dirs;
4496
4497         if (path == ".") {
4498                 return;
4499         }
4500
4501         switch (type) {
4502         case DataType::AUDIO:
4503                 search_path = config.get_audio_search_path ();
4504                 break;
4505         case DataType::MIDI:
4506                 search_path = config.get_midi_search_path ();
4507                 break;
4508         }
4509
4510         split (search_path, dirs, ':');
4511
4512         for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
4513                 /* No need to add this new directory if it has the same inode as
4514                    an existing one; checking inode rather than name prevents duplicated
4515                    directories when we are using symlinks.
4516
4517                    On Windows, I think we could just do if (*i == path) here.
4518                 */
4519                 if (PBD::equivalent_paths (*i, path)) {
4520                         return;
4521                 }
4522         }
4523
4524         if (!search_path.empty()) {
4525                 search_path += ':';
4526         }
4527
4528         search_path += path;
4529
4530         switch (type) {
4531         case DataType::AUDIO:
4532                 config.set_audio_search_path (search_path);
4533                 break;
4534         case DataType::MIDI:
4535                 config.set_midi_search_path (search_path);
4536                 break;
4537         }
4538 }
4539
4540 boost::shared_ptr<Speakers>
4541 Session::get_speakers()
4542 {
4543         return _speakers;
4544 }
4545
4546 list<string>
4547 Session::unknown_processors () const
4548 {
4549         list<string> p;
4550
4551         boost::shared_ptr<RouteList> r = routes.reader ();
4552         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4553                 list<string> t = (*i)->unknown_processors ();
4554                 copy (t.begin(), t.end(), back_inserter (p));
4555         }
4556
4557         p.sort ();
4558         p.unique ();
4559
4560         return p;
4561 }
4562
4563 void
4564 Session::update_latency (bool playback)
4565 {
4566         DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
4567
4568         if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
4569                 return;
4570         }
4571
4572         boost::shared_ptr<RouteList> r = routes.reader ();
4573         framecnt_t max_latency = 0;
4574
4575         if (playback) {
4576                 /* reverse the list so that we work backwards from the last route to run to the first */
4577                 RouteList* rl = routes.reader().get();
4578                 r.reset (new RouteList (*rl));
4579                 reverse (r->begin(), r->end());
4580         }
4581
4582         /* compute actual latency values for the given direction and store them all in per-port
4583            structures. this will also publish the same values (to JACK) so that computation of latency
4584            for routes can consistently use public latency values.
4585         */
4586
4587         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4588                 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
4589         }
4590
4591         /* because we latency compensate playback, our published playback latencies should
4592            be the same for all output ports - all material played back by ardour has
4593            the same latency, whether its caused by plugins or by latency compensation. since
4594            these may differ from the values computed above, reset all playback port latencies
4595            to the same value.
4596         */
4597
4598         DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
4599
4600         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4601                 (*i)->set_public_port_latencies (max_latency, playback);
4602         }
4603
4604         if (playback) {
4605
4606                 post_playback_latency ();
4607
4608         } else {
4609
4610                 post_capture_latency ();
4611         }
4612
4613         DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
4614 }
4615
4616 void
4617 Session::post_playback_latency ()
4618 {
4619         set_worst_playback_latency ();
4620
4621         boost::shared_ptr<RouteList> r = routes.reader ();
4622
4623         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4624                 if (!(*i)->is_auditioner() && ((*i)->active())) {
4625                         _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
4626                 }
4627         }
4628
4629         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4630                 (*i)->set_latency_compensation (_worst_track_latency);
4631         }
4632 }
4633
4634 void
4635 Session::post_capture_latency ()
4636 {
4637         set_worst_capture_latency ();
4638
4639         /* reflect any changes in capture latencies into capture offsets
4640          */
4641
4642         boost::shared_ptr<RouteList> rl = routes.reader();
4643         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4644                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4645                 if (tr) {
4646                         tr->set_capture_offset ();
4647                 }
4648         }
4649 }
4650
4651 void
4652 Session::initialize_latencies ()
4653 {
4654         {
4655                 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
4656                 update_latency (false);
4657                 update_latency (true);
4658         }
4659
4660         set_worst_io_latencies ();
4661 }
4662
4663 void
4664 Session::set_worst_io_latencies ()
4665 {
4666         set_worst_playback_latency ();
4667         set_worst_capture_latency ();
4668 }
4669
4670 void
4671 Session::set_worst_playback_latency ()
4672 {
4673         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4674                 return;
4675         }
4676
4677         _worst_output_latency = 0;
4678
4679         if (!_engine.connected()) {
4680                 return;
4681         }
4682
4683         boost::shared_ptr<RouteList> r = routes.reader ();
4684
4685         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4686                 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
4687         }
4688
4689         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
4690 }
4691
4692 void
4693 Session::set_worst_capture_latency ()
4694 {
4695         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4696                 return;
4697         }
4698
4699         _worst_input_latency = 0;
4700
4701         if (!_engine.connected()) {
4702                 return;
4703         }
4704
4705         boost::shared_ptr<RouteList> r = routes.reader ();
4706
4707         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4708                 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
4709         }
4710
4711         DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
4712 }
4713
4714 void
4715 Session::update_latency_compensation (bool force_whole_graph)
4716 {
4717         bool some_track_latency_changed = false;
4718
4719         if (_state_of_the_state & (InitialConnecting|Deletion)) {
4720                 return;
4721         }
4722
4723         DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
4724
4725         _worst_track_latency = 0;
4726
4727         boost::shared_ptr<RouteList> r = routes.reader ();
4728
4729         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4730                 if (!(*i)->is_auditioner() && ((*i)->active())) {
4731                         framecnt_t tl;
4732                         if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
4733                                 some_track_latency_changed = true;
4734                         }
4735                         _worst_track_latency = max (tl, _worst_track_latency);
4736                 }
4737         }
4738
4739         DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
4740                                                      (some_track_latency_changed ? "yes" : "no")));
4741
4742         DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
4743
4744         if (some_track_latency_changed || force_whole_graph)  {
4745                 _engine.update_latencies ();
4746         }
4747
4748
4749         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4750                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4751                 if (!tr) {
4752                         continue;
4753                 }
4754                 tr->set_capture_offset ();
4755         }
4756 }
4757
4758 char
4759 Session::session_name_is_legal (const string& path)
4760 {
4761         char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
4762
4763         for (int i = 0; illegal_chars[i]; ++i) {
4764                 if (path.find (illegal_chars[i]) != string::npos) {
4765                         return illegal_chars[i];
4766                 }
4767         }
4768
4769         return 0;
4770 }
4771
4772 uint32_t
4773 Session::next_control_id () const
4774 {
4775         int subtract = 0;
4776
4777         /* the monitor bus remote ID is in a different
4778          * "namespace" than regular routes. its existence doesn't
4779          * affect normal (low) numbered routes.
4780          */
4781
4782         if (_monitor_out) {
4783                 subtract++;
4784         }
4785
4786         return nroutes() - subtract;
4787 }
4788
4789 void
4790 Session::notify_remote_id_change ()
4791 {
4792         if (deletion_in_progress()) {
4793                 return;
4794         }
4795
4796         switch (Config->get_remote_model()) {
4797         case MixerSort:
4798         case EditorSort:
4799                 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
4800                 break;
4801         default:
4802                 break;
4803         }
4804 }
4805
4806 void
4807 Session::sync_order_keys (RouteSortOrderKey sort_key_changed)
4808 {
4809         if (deletion_in_progress()) {
4810                 return;
4811         }
4812
4813         /* tell everyone that something has happened to the sort keys
4814            and let them sync up with the change(s)
4815            this will give objects that manage the sort order keys the
4816            opportunity to keep them in sync if they wish to.
4817         */
4818
4819         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("Sync Order Keys, based on %1\n", enum_2_string (sort_key_changed)));
4820
4821         Route::SyncOrderKeys (sort_key_changed); /* EMIT SIGNAL */
4822
4823         DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
4824 }
4825
4826 bool
4827 Session::operation_in_progress (GQuark op) const
4828 {
4829         return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
4830 }
4831
4832 boost::shared_ptr<Port>
4833 Session::ltc_input_port () const
4834 {
4835         return _ltc_input->nth (0);
4836 }
4837
4838 boost::shared_ptr<Port>
4839 Session::ltc_output_port () const
4840 {
4841         return _ltc_output->nth (0);
4842 }
4843
4844 void
4845 Session::reconnect_ltc_input ()
4846 {
4847         if (_ltc_input) {
4848
4849                 string src = Config->get_ltc_source_port();
4850
4851                 _ltc_input->disconnect (this);
4852
4853                 if (src != _("None") && !src.empty())  {
4854                         _ltc_input->nth (0)->connect (src);
4855                 }
4856         }
4857 }
4858
4859 void
4860 Session::reconnect_ltc_output ()
4861 {
4862         if (_ltc_output) {
4863
4864 #if 0
4865                 string src = Config->get_ltc_sink_port();
4866
4867                 _ltc_output->disconnect (this);
4868
4869                 if (src != _("None") && !src.empty())  {
4870                         _ltc_output->nth (0)->connect (src);
4871                 }
4872 #endif
4873         }
4874 }