libs/ardour/session.cc

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