libs/ardour/session.cc

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