libs/ardour/session.cc

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