libs/ardour/session.cc

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