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