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