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