libs/ardour/session.cc

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