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