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