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