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