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