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