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