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