libs/ardour/session.cc

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