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