libs/ardour/session.cc

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