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