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