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
1488                         if (route_group) {
1489                                 route_group->add (track);
1490                         }
1491
1492                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1493                         track->set_remote_control_id (control_id);
1494
1495                         new_routes.push_back (track);
1496                         ret.push_back (track);
1497                 }
1498
1499                 catch (failed_constructor &err) {
1500                         error << _("Session: could not create new midi track.") << endmsg;
1501                         goto failed;
1502                 }
1503
1504                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1505
1506                         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;
1507                         goto failed;
1508                 }
1509
1510                 --how_many;
1511         }
1512
1513   failed:
1514         if (!new_routes.empty()) {
1515                 add_routes (new_routes, false);
1516                 save_state (_current_snapshot_name);
1517         }
1518
1519         return ret;
1520 }
1521
1522 void
1523 Session::auto_connect_route (boost::shared_ptr<Route> route,
1524                 ChanCount& existing_inputs, ChanCount& existing_outputs)
1525 {
1526         /* If both inputs and outputs are auto-connected to physical ports,
1527            use the max of input and output offsets to ensure auto-connected
1528            port numbers always match up (e.g. the first audio input and the
1529            first audio output of the route will have the same physical
1530            port number).  Otherwise just use the lowest input or output
1531            offset possible.
1532         */
1533         const bool in_out_physical =
1534                    (Config->get_input_auto_connect() & AutoConnectPhysical)
1535                 && (Config->get_output_auto_connect() & AutoConnectPhysical);
1536
1537         const ChanCount in_offset = in_out_physical
1538                 ? ChanCount::max(existing_inputs, existing_outputs)
1539                 : existing_inputs;
1540
1541         const ChanCount out_offset = in_out_physical
1542                 ? ChanCount::max(existing_inputs, existing_outputs)
1543                 : existing_outputs;
1544
1545         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1546                 vector<string> physinputs;
1547                 vector<string> physoutputs;
1548
1549                 _engine.get_physical_outputs (*t, physoutputs);
1550                 _engine.get_physical_inputs (*t, physinputs);
1551
1552                 if (!physinputs.empty()) {
1553                         uint32_t nphysical_in = physinputs.size();
1554                         for (uint32_t i = 0; i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
1555                                 string port;
1556
1557                                 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1558                                         port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
1559                                 }
1560
1561                                 if (!port.empty() && route->input()->connect (
1562                                                 route->input()->ports().port(*t, i), port, this)) {
1563                                         break;
1564                                 }
1565                         }
1566                 }
1567
1568                 if (!physoutputs.empty()) {
1569                         uint32_t nphysical_out = physoutputs.size();
1570                         for (uint32_t i = 0; i < route->n_outputs().get(*t); ++i) {
1571                                 string port;
1572
1573                                 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1574                                         port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
1575                                 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1576                                         if (_master_out && _master_out->n_inputs().get(*t) > 0) {
1577                                                 port = _master_out->input()->ports().port(*t,
1578                                                                 i % _master_out->input()->n_ports().get(*t))->name();
1579                                         }
1580                                 }
1581
1582                                 if (!port.empty() && route->output()->connect (
1583                                                 route->output()->ports().port(*t, i), port, this)) {
1584                                         break;
1585                                 }
1586                         }
1587                 }
1588         }
1589
1590         existing_inputs += route->n_inputs();
1591         existing_outputs += route->n_outputs();
1592 }
1593
1594 list< boost::shared_ptr<AudioTrack> >
1595 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many)
1596 {
1597         char track_name[32];
1598         uint32_t track_id = 0;
1599         ChanCount existing_inputs;
1600         ChanCount existing_outputs;
1601         string port;
1602         RouteList new_routes;
1603         list<boost::shared_ptr<AudioTrack> > ret;
1604         uint32_t control_id;
1605
1606         count_existing_route_channels (existing_inputs, existing_outputs);
1607
1608         control_id = ntracks() + nbusses() + 1;
1609
1610         while (how_many) {
1611                 if (!find_route_name ("Audio", ++track_id, track_name, sizeof(track_name))) {
1612                         error << "cannot find name for new audio track" << endmsg;
1613                         goto failed;
1614                 }
1615
1616                 shared_ptr<AudioTrack> track;
1617
1618                 try {
1619                         AudioTrack* at = new AudioTrack (*this, track_name, Route::Flag (0), mode);
1620
1621                         if (at->init ()) {
1622                                 delete at;
1623                                 goto failed;
1624                         }
1625
1626                         at->use_new_diskstream();
1627
1628                         boost_debug_shared_ptr_mark_interesting (at, "Track");
1629                         track = boost::shared_ptr<AudioTrack>(at);
1630
1631                         if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1632                                 error << string_compose (
1633                                                         _("cannot configure %1 in/%2 out configuration for new audio track"),
1634                                                          input_channels, output_channels)
1635                                       << endmsg;
1636                                 goto failed;
1637                         }
1638
1639                         if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1640                                 error << string_compose (
1641                                                         _("cannot configure %1 in/%2 out configuration for new audio track"),
1642                                                          input_channels, output_channels)
1643                                       << endmsg;
1644                                 goto failed;
1645                         }
1646
1647                         auto_connect_route (track, existing_inputs, existing_outputs);
1648
1649                         if (route_group) {
1650                                 route_group->add (track);
1651                         }
1652
1653                         track->non_realtime_input_change();
1654
1655                         track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1656                         track->set_remote_control_id (control_id);
1657                         ++control_id;
1658
1659                         new_routes.push_back (track);
1660                         ret.push_back (track);
1661                 }
1662
1663                 catch (failed_constructor &err) {
1664                         error << _("Session: could not create new audio track.") << endmsg;
1665                         goto failed;
1666                 }
1667
1668                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1669
1670                         error << pfe.what() << endmsg;
1671                         goto failed;
1672                 }
1673
1674                 --how_many;
1675         }
1676
1677   failed:
1678         if (!new_routes.empty()) {
1679                 add_routes (new_routes, true);
1680         }
1681
1682         return ret;
1683 }
1684
1685 void
1686 Session::set_remote_control_ids ()
1687 {
1688         RemoteModel m = Config->get_remote_model();
1689         bool emit_signal = false;
1690
1691         shared_ptr<RouteList> r = routes.reader ();
1692
1693         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1694                 if (MixerOrdered == m) {
1695                         long order = (*i)->order_key(N_("signal"));
1696                         (*i)->set_remote_control_id (order+1, false);
1697                         emit_signal = true;
1698                 } else if (EditorOrdered == m) {
1699                         long order = (*i)->order_key(N_("editor"));
1700                         (*i)->set_remote_control_id (order+1, false);
1701                         emit_signal = true;
1702                 } else if (UserOrdered == m) {
1703                         //do nothing ... only changes to remote id's are initiated by user
1704                 }
1705         }
1706
1707         if (emit_signal) {
1708                 Route::RemoteControlIDChange();
1709         }
1710 }
1711
1712
1713 RouteList
1714 Session::new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
1715 {
1716         char bus_name[32];
1717         uint32_t bus_id = 0;
1718         ChanCount existing_inputs;
1719         ChanCount existing_outputs;
1720         string port;
1721         RouteList ret;
1722         uint32_t control_id;
1723
1724         count_existing_route_channels (existing_inputs, existing_outputs);
1725
1726         control_id = ntracks() + nbusses() + 1;
1727
1728         while (how_many) {
1729                 if (!find_route_name ("Bus", ++bus_id, bus_name, sizeof(bus_name))) {
1730                         error << "cannot find name for new audio bus" << endmsg;
1731                         goto failure;
1732                 }
1733
1734                 try {
1735                         Route* rt = new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO);
1736
1737                         if (rt->init ()) {
1738                                 delete rt;
1739                                 goto failure;
1740                         }
1741
1742                         boost_debug_shared_ptr_mark_interesting (rt, "Route");
1743                         shared_ptr<Route> bus (rt);
1744
1745                         if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
1746                                 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1747                                                          input_channels, output_channels)
1748                                       << endmsg;
1749                                 goto failure;
1750                         }
1751
1752
1753                         if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
1754                                 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1755                                                          input_channels, output_channels)
1756                                       << endmsg;
1757                                 goto failure;
1758                         }
1759
1760                         auto_connect_route (bus, existing_inputs, existing_outputs);
1761
1762                         if (route_group) {
1763                                 route_group->add (bus);
1764                         }
1765                         bus->set_remote_control_id (control_id);
1766                         ++control_id;
1767
1768                         if (aux) {
1769                                 bus->add_internal_return ();
1770                         }
1771
1772                         ret.push_back (bus);
1773                 }
1774
1775
1776                 catch (failed_constructor &err) {
1777                         error << _("Session: could not create new audio route.") << endmsg;
1778                         goto failure;
1779                 }
1780
1781                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1782                         error << pfe.what() << endmsg;
1783                         goto failure;
1784                 }
1785
1786
1787                 --how_many;
1788         }
1789
1790   failure:
1791         if (!ret.empty()) {
1792                 add_routes (ret, true);
1793         }
1794
1795         return ret;
1796
1797 }
1798
1799 RouteList
1800 Session::new_route_from_template (uint32_t how_many, const std::string& template_path)
1801 {
1802         char name[32];
1803         RouteList ret;
1804         uint32_t control_id;
1805         XMLTree tree;
1806         uint32_t number = 0;
1807
1808         if (!tree.read (template_path.c_str())) {
1809                 return ret;
1810         }
1811
1812         XMLNode* node = tree.root();
1813
1814         control_id = ntracks() + nbusses() + 1;
1815
1816         while (how_many) {
1817
1818                 XMLNode node_copy (*node); // make a copy so we can change the name if we need to
1819
1820                 std::string node_name = IO::name_from_state (*node_copy.children().front());
1821
1822                 /* generate a new name by adding a number to the end of the template name */
1823                 if (!find_route_name (node_name.c_str(), ++number, name, sizeof(name))) {
1824                         fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
1825                         /*NOTREACHED*/
1826                 }
1827
1828                 /* set IO children to use the new name */
1829                 XMLNodeList const & children = node_copy.children ();
1830                 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
1831                         if ((*i)->name() == IO::state_node_name) {
1832                                 IO::set_name_in_state (**i, name);
1833                         }
1834                 }
1835
1836                 Track::zero_diskstream_id_in_xml (node_copy);
1837
1838                 try {
1839                         shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
1840
1841                         if (route == 0) {
1842                                 error << _("Session: cannot create track/bus from template description") << endmsg;
1843                                 goto out;
1844                         }
1845
1846                         if (boost::dynamic_pointer_cast<Track>(route)) {
1847                                 /* force input/output change signals so that the new diskstream
1848                                    picks up the configuration of the route. During session
1849                                    loading this normally happens in a different way.
1850                                 */
1851                                 route->input()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
1852                                 route->output()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
1853                         }
1854
1855                         route->set_remote_control_id (control_id);
1856                         ++control_id;
1857
1858                         ret.push_back (route);
1859                 }
1860
1861                 catch (failed_constructor &err) {
1862                         error << _("Session: could not create new route from template") << endmsg;
1863                         goto out;
1864                 }
1865
1866                 catch (AudioEngine::PortRegistrationFailure& pfe) {
1867                         error << pfe.what() << endmsg;
1868                         goto out;
1869                 }
1870
1871                 --how_many;
1872         }
1873
1874   out:
1875         if (!ret.empty()) {
1876                 add_routes (ret, true);
1877         }
1878
1879         return ret;
1880 }
1881
1882 void
1883 Session::add_routes (RouteList& new_routes, bool save)
1884 {
1885         {
1886                 RCUWriter<RouteList> writer (routes);
1887                 shared_ptr<RouteList> r = writer.get_copy ();
1888                 r->insert (r->end(), new_routes.begin(), new_routes.end());
1889
1890
1891                 /* if there is no control out and we're not in the middle of loading,
1892                    resort the graph here. if there is a control out, we will resort
1893                    toward the end of this method. if we are in the middle of loading,
1894                    we will resort when done.
1895                 */
1896
1897                 if (!_monitor_out && IO::connecting_legal) {
1898                         resort_routes_using (r);
1899                 }
1900         }
1901
1902         for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
1903
1904                 boost::weak_ptr<Route> wpr (*x);
1905                 boost::shared_ptr<Route> r (*x);
1906
1907                 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
1908                 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
1909                 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
1910                 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
1911                 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
1912                 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
1913                 r->route_group_changed.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
1914
1915                 if (r->is_master()) {
1916                         _master_out = r;
1917                 }
1918
1919                 if (r->is_monitor()) {
1920                         _monitor_out = r;
1921                 }
1922
1923                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
1924                 if (tr) {
1925                         tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
1926                         track_playlist_changed (boost::weak_ptr<Track> (tr));
1927                         tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
1928                 }
1929         }
1930
1931         if (_monitor_out && IO::connecting_legal) {
1932
1933                 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
1934                         if ((*x)->is_monitor()) {
1935                                 /* relax */
1936                         } else if ((*x)->is_master()) {
1937                                 /* relax */
1938                         } else {
1939                                 (*x)->listen_via (_monitor_out,
1940                                                   (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
1941                                                   false, false);
1942                         }
1943                 }
1944
1945                 resort_routes ();
1946         }
1947
1948         set_dirty();
1949
1950         if (save) {
1951                 save_state (_current_snapshot_name);
1952         }
1953
1954         RouteAdded (new_routes); /* EMIT SIGNAL */
1955         Route::RemoteControlIDChange (); /* EMIT SIGNAL */
1956 }
1957
1958 void
1959 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
1960 {
1961         boost::shared_ptr<RouteList> r = routes.reader ();
1962         boost::shared_ptr<Send> s;
1963
1964         /* only tracks */
1965
1966         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1967                 if (boost::dynamic_pointer_cast<Track>(*i)) {
1968                         if ((s = (*i)->internal_send_for (dest)) != 0) {
1969                                 s->amp()->gain_control()->set_value (0.0);
1970                         }
1971                 }
1972         }
1973 }
1974
1975 void
1976 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
1977 {
1978         boost::shared_ptr<RouteList> r = routes.reader ();
1979         boost::shared_ptr<Send> s;
1980
1981         /* only tracks */
1982
1983         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1984                 if (boost::dynamic_pointer_cast<Track>(*i)) {
1985                         if ((s = (*i)->internal_send_for (dest)) != 0) {
1986                                 s->amp()->gain_control()->set_value (1.0);
1987                         }
1988                 }
1989         }
1990 }
1991
1992 void
1993 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
1994 {
1995         boost::shared_ptr<RouteList> r = routes.reader ();
1996         boost::shared_ptr<Send> s;
1997
1998         /* only tracks */
1999
2000         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2001                 if (boost::dynamic_pointer_cast<Track>(*i)) {
2002                         if ((s = (*i)->internal_send_for (dest)) != 0) {
2003                                 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
2004                         }
2005                 }
2006         }
2007 }
2008
2009 void
2010 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p)
2011 {
2012         boost::shared_ptr<RouteList> r = routes.reader ();
2013         boost::shared_ptr<RouteList> t (new RouteList);
2014
2015         /* only send tracks */
2016
2017         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2018                 if (boost::dynamic_pointer_cast<Track>(*i)) {
2019                         t->push_back (*i);
2020                 }
2021         }
2022
2023         add_internal_sends (dest, p, t);
2024 }
2025
2026 void
2027 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2028 {
2029         if (dest->is_monitor() || dest->is_master()) {
2030                 return;
2031         }
2032
2033         if (!dest->internal_return()) {
2034                 dest->add_internal_return();
2035         }
2036
2037         for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
2038
2039                 if ((*i)->is_monitor() || (*i)->is_master() || (*i) == dest) {
2040                         continue;
2041                 }
2042
2043                 (*i)->listen_via (dest, p, true, true);
2044         }
2045
2046         graph_reordered ();
2047 }
2048
2049 void
2050 Session::remove_route (shared_ptr<Route> route)
2051 {
2052         if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
2053                 return;
2054         }
2055
2056         {
2057                 RCUWriter<RouteList> writer (routes);
2058                 shared_ptr<RouteList> rs = writer.get_copy ();
2059
2060                 rs->remove (route);
2061
2062                 /* deleting the master out seems like a dumb
2063                    idea, but its more of a UI policy issue
2064                    than our concern.
2065                 */
2066
2067                 if (route == _master_out) {
2068                         _master_out = shared_ptr<Route> ();
2069                 }
2070
2071                 if (route == _monitor_out) {
2072
2073                         /* cancel control outs for all routes */
2074
2075                         for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2076                                 (*r)->drop_listen (_monitor_out);
2077                         }
2078
2079                         _monitor_out.reset ();
2080                 }
2081
2082                 /* writer goes out of scope, forces route list update */
2083         }
2084
2085         update_route_solo_state ();
2086         update_session_range_location_marker ();
2087
2088         // We need to disconnect the route's inputs and outputs
2089
2090         route->input()->disconnect (0);
2091         route->output()->disconnect (0);
2092
2093         /* if the route had internal sends sending to it, remove them */
2094         if (route->internal_return()) {
2095
2096                 boost::shared_ptr<RouteList> r = routes.reader ();
2097                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2098                         boost::shared_ptr<Send> s = (*i)->internal_send_for (route);
2099                         if (s) {
2100                                 (*i)->remove_processor (s);
2101                         }
2102                 }
2103         }
2104
2105         update_latency_compensation (false, false);
2106         set_dirty();
2107
2108         /* get rid of it from the dead wood collection in the route list manager */
2109
2110         /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2111
2112         routes.flush ();
2113
2114         /* try to cause everyone to drop their references */
2115
2116         route->drop_references ();
2117
2118         sync_order_keys (N_("session"));
2119
2120         Route::RemoteControlIDChange(); /* EMIT SIGNAL */
2121
2122         /* save the new state of the world */
2123
2124         if (save_state (_current_snapshot_name)) {
2125                 save_history (_current_snapshot_name);
2126         }
2127 }
2128
2129 void
2130 Session::route_mute_changed (void* /*src*/)
2131 {
2132         set_dirty ();
2133 }
2134
2135 void
2136 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2137 {
2138         boost::shared_ptr<Route> route = wpr.lock();
2139         if (!route) {
2140                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2141                 return;
2142         }
2143
2144         if (route->listening()) {
2145
2146                 if (Config->get_exclusive_solo()) {
2147                         /* new listen: disable all other listen */
2148                         shared_ptr<RouteList> r = routes.reader ();
2149                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2150                                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2151                                         continue;
2152                                 }
2153                                 (*i)->set_listen (false, this);
2154                         }
2155                 }
2156
2157                 _listen_cnt++;
2158
2159         } else if (_listen_cnt > 0) {
2160
2161                 _listen_cnt--;
2162         }
2163 }
2164 void
2165 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
2166 {
2167         boost::shared_ptr<Route> route = wpr.lock ();
2168
2169         if (!route) {
2170                 /* should not happen */
2171                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2172                 return;
2173         }
2174
2175         bool send_changed = false;
2176
2177         if (route->solo_isolated()) {
2178                 if (_solo_isolated_cnt == 0) {
2179                         send_changed = true;
2180                 }
2181                 _solo_isolated_cnt++;
2182         } else if (_solo_isolated_cnt > 0) {
2183                 _solo_isolated_cnt--;
2184                 if (_solo_isolated_cnt == 0) {
2185                         send_changed = true;
2186                 }
2187         }
2188
2189         if (send_changed) {
2190                 IsolatedChanged (); /* EMIT SIGNAL */
2191         }
2192 }
2193
2194 void
2195 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
2196 {
2197         if (!self_solo_change) {
2198                 // session doesn't care about changes to soloed-by-others
2199                 return;
2200         }
2201
2202         if (solo_update_disabled) {
2203                 // We know already
2204                 return;
2205         }
2206
2207         boost::shared_ptr<Route> route = wpr.lock ();
2208
2209         if (!route) {
2210                 /* should not happen */
2211                 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2212                 return;
2213         }
2214
2215         shared_ptr<RouteList> r = routes.reader ();
2216         int32_t delta;
2217
2218         if (route->self_soloed()) {
2219                 delta = 1;
2220         } else {
2221                 delta = -1;
2222         }
2223
2224         if (delta == 1 && Config->get_exclusive_solo()) {
2225                 /* new solo: disable all other solos */
2226                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2227                         if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2228                                 continue;
2229                         }
2230                         (*i)->set_solo (false, this);
2231                 }
2232         }
2233
2234         solo_update_disabled = true;
2235
2236         RouteList uninvolved;
2237
2238         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2239                 bool via_sends_only;
2240                 bool in_signal_flow;
2241
2242                 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2243                         continue;
2244                 }
2245
2246                 in_signal_flow = false;
2247
2248                 if ((*i)->feeds (route, &via_sends_only)) {
2249                         if (!via_sends_only) {
2250                                 if (!route->soloed_by_others_upstream()) {
2251                                         (*i)->mod_solo_by_others_downstream (delta);
2252                                 }
2253                                 in_signal_flow = true;
2254                         }
2255                 }
2256
2257                 if (route->feeds (*i, &via_sends_only)) {
2258                         (*i)->mod_solo_by_others_upstream (delta);
2259                         in_signal_flow = true;
2260                 }
2261
2262                 if (!in_signal_flow) {
2263                         uninvolved.push_back (*i);
2264                 }
2265         }
2266
2267         solo_update_disabled = false;
2268         update_route_solo_state (r);
2269
2270         /* now notify that the mute state of the routes not involved in the signal
2271            pathway of the just-solo-changed route may have altered.
2272         */
2273
2274         for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
2275                 (*i)->mute_changed (this);
2276         }
2277
2278         SoloChanged (); /* EMIT SIGNAL */
2279         set_dirty();
2280 }
2281
2282 void
2283 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
2284 {
2285         /* now figure out if anything that matters is soloed (or is "listening")*/
2286
2287         bool something_soloed = false;
2288         uint32_t listeners = 0;
2289         uint32_t isolated = 0;
2290
2291         if (!r) {
2292                 r = routes.reader();
2293         }
2294
2295         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2296                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden() && (*i)->self_soloed()) {
2297                         something_soloed = true;
2298                 }
2299
2300                 if (!(*i)->is_hidden() && (*i)->listening()) {
2301                         if (Config->get_solo_control_is_listen_control()) {
2302                                 listeners++;
2303                         } else {
2304                                 (*i)->set_listen (false, this);
2305                         }
2306                 }
2307
2308                 if ((*i)->solo_isolated()) {
2309                         isolated++;
2310                 }
2311         }
2312
2313         if (something_soloed != _non_soloed_outs_muted) {
2314                 _non_soloed_outs_muted = something_soloed;
2315                 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
2316         }
2317
2318         _listen_cnt = listeners;
2319
2320         if (isolated != _solo_isolated_cnt) {
2321                 _solo_isolated_cnt = isolated;
2322                 IsolatedChanged (); /* EMIT SIGNAL */
2323         }
2324 }
2325
2326 boost::shared_ptr<RouteList>
2327 Session::get_routes_with_internal_returns() const
2328 {
2329         shared_ptr<RouteList> r = routes.reader ();
2330         boost::shared_ptr<RouteList> rl (new RouteList);
2331
2332         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2333                 if ((*i)->internal_return ()) {
2334                         rl->push_back (*i);
2335                 }
2336         }
2337         return rl;
2338 }
2339
2340 bool
2341 Session::io_name_is_legal (const std::string& name)
2342 {
2343         shared_ptr<RouteList> r = routes.reader ();
2344
2345         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2346                 if ((*i)->name() == name) {
2347                         return false;
2348                 }
2349
2350                 if ((*i)->has_io_processor_named (name)) {
2351                         return false;
2352                 }
2353         }
2354
2355         return true;
2356 }
2357
2358 shared_ptr<Route>
2359 Session::route_by_name (string name)
2360 {
2361         shared_ptr<RouteList> r = routes.reader ();
2362
2363         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2364                 if ((*i)->name() == name) {
2365                         return *i;
2366                 }
2367         }
2368
2369         return shared_ptr<Route> ((Route*) 0);
2370 }
2371
2372 shared_ptr<Route>
2373 Session::route_by_id (PBD::ID id)
2374 {
2375         shared_ptr<RouteList> r = routes.reader ();
2376
2377         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2378                 if ((*i)->id() == id) {
2379                         return *i;
2380                 }
2381         }
2382
2383         return shared_ptr<Route> ((Route*) 0);
2384 }
2385
2386 shared_ptr<Route>
2387 Session::route_by_remote_id (uint32_t id)
2388 {
2389         shared_ptr<RouteList> r = routes.reader ();
2390
2391         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2392                 if ((*i)->remote_control_id() == id) {
2393                         return *i;
2394                 }
2395         }
2396
2397         return shared_ptr<Route> ((Route*) 0);
2398 }
2399
2400 /** If either end of the session range location marker lies inside the current
2401  *  session extent, move it to the corresponding session extent.
2402  */
2403 void
2404 Session::update_session_range_location_marker ()
2405 {
2406         if (_state_of_the_state & Loading) {
2407                 return;
2408         }
2409
2410         pair<nframes_t, nframes_t> const ext = get_extent ();
2411
2412         if (_session_range_location == 0) {
2413                 /* we don't have a session range yet; use this one (provided it is valid) */
2414                 if (ext.first != max_frames) {
2415                         add_session_range_location (ext.first, ext.second);
2416                 }
2417         } else {
2418                 /* update the existing session range */
2419                 if (ext.first < _session_range_location->start()) {
2420                         _session_range_location->set_start (ext.first);
2421                         set_dirty ();
2422                 }
2423
2424                 if (ext.second > _session_range_location->end()) {
2425                         _session_range_location->set_end (ext.second);
2426                         set_dirty ();
2427                 }
2428
2429         }
2430 }
2431
2432 /** @return Extent of the session's contents; if the session is empty, the first value of
2433  *  the pair will equal max_frames.
2434  */
2435 pair<nframes_t, nframes_t>
2436 Session::get_extent () const
2437 {
2438         pair<nframes_t, nframes_t> ext (max_frames, 0);
2439
2440         boost::shared_ptr<RouteList> rl = routes.reader ();
2441         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2442                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2443                 if (!tr || tr->destructive()) {
2444                         // ignore tape tracks when getting extents
2445                         continue;
2446                 }
2447
2448                 pair<nframes_t, nframes_t> e = tr->playlist()->get_extent ();
2449                 if (e.first < ext.first) {
2450                         ext.first = e.first;
2451                 }
2452                 if (e.second > ext.second) {
2453                         ext.second = e.second;
2454                 }
2455         }
2456
2457         return ext;
2458 }
2459
2460 /* Region management */
2461
2462 boost::shared_ptr<Region>
2463 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
2464 {
2465         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2466         RegionFactory::RegionMap::const_iterator i;
2467         boost::shared_ptr<Region> region;
2468
2469         Glib::Mutex::Lock lm (region_lock);
2470
2471         for (i = regions.begin(); i != regions.end(); ++i) {
2472
2473                 region = i->second;
2474
2475                 if (region->whole_file()) {
2476
2477                         if (child->source_equivalent (region)) {
2478                                 return region;
2479                         }
2480                 }
2481         }
2482
2483         return boost::shared_ptr<Region> ();
2484 }
2485
2486 int
2487 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
2488 {
2489         set<boost::shared_ptr<Region> > relevant_regions;
2490
2491         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
2492                 RegionFactory::get_regions_using_source (*s, relevant_regions);
2493         }
2494
2495         cerr << "There are " << relevant_regions.size() << " using " << srcs.size() << " sources" << endl;
2496
2497         for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2498                 set<boost::shared_ptr<Region> >::iterator tmp;
2499
2500                 tmp = r;
2501                 ++tmp;
2502
2503                 cerr << "Cleanup " << (*r)->name() << " UC = " << (*r).use_count() << endl;
2504
2505                 playlists->destroy_region (*r);
2506                 RegionFactory::map_remove (*r);
2507
2508                 (*r)->drop_sources ();
2509                 (*r)->drop_references ();
2510
2511                 cerr << "\tdone UC = " << (*r).use_count() << endl;
2512
2513                 relevant_regions.erase (r);
2514
2515                 r = tmp;
2516         }
2517
2518         for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
2519
2520                 {
2521                         Glib::Mutex::Lock ls (source_lock);
2522                         /* remove from the main source list */
2523                         sources.erase ((*s)->id());
2524                 }
2525
2526                 (*s)->mark_for_remove ();
2527                 (*s)->drop_references ();
2528
2529                 s = srcs.erase (s);
2530         }
2531
2532         return 0;
2533 }
2534
2535 int
2536 Session::remove_last_capture ()
2537 {
2538         list<boost::shared_ptr<Source> > srcs;
2539
2540         boost::shared_ptr<RouteList> rl = routes.reader ();
2541         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2542                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2543                 if (!tr) {
2544                         continue;
2545                 }
2546
2547                 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
2548
2549                 if (!l.empty()) {
2550                         srcs.insert (srcs.end(), l.begin(), l.end());
2551                         l.clear ();
2552                 }
2553         }
2554
2555         destroy_sources (srcs);
2556
2557         save_state (_current_snapshot_name);
2558
2559         return 0;
2560 }
2561
2562 /* Source Management */
2563
2564 void
2565 Session::add_source (boost::shared_ptr<Source> source)
2566 {
2567         pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2568         pair<SourceMap::iterator,bool> result;
2569
2570         entry.first = source->id();
2571         entry.second = source;
2572
2573         {
2574                 Glib::Mutex::Lock lm (source_lock);
2575                 result = sources.insert (entry);
2576         }
2577
2578         if (result.second) {
2579
2580                 /* yay, new source */
2581
2582                 set_dirty();
2583
2584                 boost::shared_ptr<AudioFileSource> afs;
2585
2586                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2587                         if (Config->get_auto_analyse_audio()) {
2588                                 Analyser::queue_source_for_analysis (source, false);
2589                         }
2590                 }
2591         }
2592 }
2593
2594 void
2595 Session::remove_source (boost::weak_ptr<Source> src)
2596 {
2597         SourceMap::iterator i;
2598         boost::shared_ptr<Source> source = src.lock();
2599
2600         if (!source) {
2601                 return;
2602         }
2603
2604         {
2605                 Glib::Mutex::Lock lm (source_lock);
2606
2607                 if ((i = sources.find (source->id())) != sources.end()) {
2608                         sources.erase (i);
2609                 }
2610         }
2611
2612         if (!_state_of_the_state & InCleanup) {
2613
2614                 /* save state so we don't end up with a session file
2615                    referring to non-existent sources.
2616                 */
2617
2618                 save_state (_current_snapshot_name);
2619         }
2620 }
2621
2622 boost::shared_ptr<Source>
2623 Session::source_by_id (const PBD::ID& id)
2624 {
2625         Glib::Mutex::Lock lm (source_lock);
2626         SourceMap::iterator i;
2627         boost::shared_ptr<Source> source;
2628
2629         if ((i = sources.find (id)) != sources.end()) {
2630                 source = i->second;
2631         }
2632
2633         return source;
2634 }
2635
2636 boost::shared_ptr<Source>
2637 Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
2638 {
2639         Glib::Mutex::Lock lm (source_lock);
2640
2641         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2642                 cerr << "comparing " << path << " with " << i->second->name() << endl;
2643                 boost::shared_ptr<AudioFileSource> afs
2644                         = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2645
2646                 if (afs && afs->path() == path && chn == afs->channel()) {
2647                         return afs;
2648                 }
2649         }
2650         return boost::shared_ptr<Source>();
2651 }
2652
2653
2654 string
2655 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
2656 {
2657         string look_for;
2658         string old_basename = PBD::basename_nosuffix (oldname);
2659         string new_legalized = legalize_for_path (newname);
2660
2661         /* note: we know (or assume) the old path is already valid */
2662
2663         if (destructive) {
2664
2665                 /* destructive file sources have a name of the form:
2666
2667                     /path/to/Tnnnn-NAME(%[LR])?.wav
2668
2669                     the task here is to replace NAME with the new name.
2670                 */
2671
2672                 /* find last slash */
2673
2674                 string dir;
2675                 string prefix;
2676                 string::size_type slash;
2677                 string::size_type dash;
2678
2679                 if ((slash = path.find_last_of ('/')) == string::npos) {
2680                         return "";
2681                 }
2682
2683                 dir = path.substr (0, slash+1);
2684
2685                 /* '-' is not a legal character for the NAME part of the path */
2686
2687                 if ((dash = path.find_last_of ('-')) == string::npos) {
2688                         return "";
2689                 }
2690
2691                 prefix = path.substr (slash+1, dash-(slash+1));
2692
2693                 path = dir;
2694                 path += prefix;
2695                 path += '-';
2696                 path += new_legalized;
2697                 path += ".wav";  /* XXX gag me with a spoon */
2698
2699         } else {
2700
2701                 /* non-destructive file sources have a name of the form:
2702
2703                     /path/to/NAME-nnnnn(%[LR])?.ext
2704
2705                     the task here is to replace NAME with the new name.
2706                 */
2707
2708                 string dir;
2709                 string suffix;
2710                 string::size_type slash;
2711                 string::size_type dash;
2712                 string::size_type postfix;
2713
2714                 /* find last slash */
2715
2716                 if ((slash = path.find_last_of ('/')) == string::npos) {
2717                         return "";
2718                 }
2719
2720                 dir = path.substr (0, slash+1);
2721
2722                 /* '-' is not a legal character for the NAME part of the path */
2723
2724                 if ((dash = path.find_last_of ('-')) == string::npos) {
2725                         return "";
2726                 }
2727
2728                 suffix = path.substr (dash+1);
2729
2730                 // Suffix is now everything after the dash. Now we need to eliminate
2731                 // the nnnnn part, which is done by either finding a '%' or a '.'
2732
2733                 postfix = suffix.find_last_of ("%");
2734                 if (postfix == string::npos) {
2735                         postfix = suffix.find_last_of ('.');
2736                 }
2737
2738                 if (postfix != string::npos) {
2739                         suffix = suffix.substr (postfix);
2740                 } else {
2741                         error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
2742                         return "";
2743                 }
2744
2745                 const uint32_t limit = 10000;
2746                 char buf[PATH_MAX+1];
2747
2748                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2749
2750                         snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
2751
2752                         if (access (buf, F_OK) != 0) {
2753                                 path = buf;
2754                                 break;
2755                         }
2756                         path = "";
2757                 }
2758
2759                 if (path == "") {
2760                         error << "FATAL ERROR! Could not find a " << endl;
2761                 }
2762
2763         }
2764
2765         return path;
2766 }
2767
2768 /** Return the full path (in some session directory) for a new within-session source.
2769  * \a name must be a session-unique name that does not contain slashes
2770  *         (e.g. as returned by new_*_source_name)
2771  */
2772 string
2773 Session::new_source_path_from_name (DataType type, const string& name)
2774 {
2775         assert(name.find("/") == string::npos);
2776
2777         SessionDirectory sdir(get_best_session_directory_for_new_source());
2778
2779         sys::path p;
2780         if (type == DataType::AUDIO) {
2781                 p = sdir.sound_path();
2782         } else if (type == DataType::MIDI) {
2783                 p = sdir.midi_path();
2784         } else {
2785                 error << "Unknown source type, unable to create file path" << endmsg;
2786                 return "";
2787         }
2788
2789         p /= name;
2790         return p.to_string();
2791 }
2792
2793 Glib::ustring
2794 Session::peak_path (Glib::ustring base) const
2795 {
2796         sys::path peakfile_path(_session_dir->peak_path());
2797         peakfile_path /= basename_nosuffix (base) + peakfile_suffix;
2798         return peakfile_path.to_string();
2799 }
2800
2801 /** Return a unique name based on \a base for a new internal audio source */
2802 string
2803 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
2804 {
2805         string spath;
2806         uint32_t cnt;
2807         char buf[PATH_MAX+1];
2808         const uint32_t limit = 10000;
2809         string legalized;
2810
2811         buf[0] = '\0';
2812         legalized = legalize_for_path (base);
2813
2814         // Find a "version" of the base name that doesn't exist in any of the possible directories.
2815         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
2816
2817                 vector<space_and_path>::iterator i;
2818                 uint32_t existing = 0;
2819
2820                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2821
2822                         SessionDirectory sdir((*i).path);
2823
2824                         spath = sdir.sound_path().to_string();
2825
2826                         if (destructive) {
2827
2828                                 if (nchan < 2) {
2829                                         snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
2830                                                         spath.c_str(), cnt, legalized.c_str());
2831                                 } else if (nchan == 2) {
2832                                         if (chan == 0) {
2833                                                 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav",
2834                                                                 spath.c_str(), cnt, legalized.c_str());
2835                                         } else {
2836                                                 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav",
2837                                                                 spath.c_str(), cnt, legalized.c_str());
2838                                         }
2839                                 } else if (nchan < 26) {
2840                                         snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav",
2841                                                         spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
2842                                 } else {
2843                                         snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
2844                                                         spath.c_str(), cnt, legalized.c_str());
2845                                 }
2846
2847                         } else {
2848
2849                                 spath += '/';
2850                                 spath += legalized;
2851
2852                                 if (nchan < 2) {
2853                                         snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
2854                                 } else if (nchan == 2) {
2855                                         if (chan == 0) {
2856                                                 snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
2857                                         } else {
2858                                                 snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
2859                                         }
2860                                 } else if (nchan < 26) {
2861                                         snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
2862                                 } else {
2863                                         snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
2864                                 }
2865                         }
2866
2867                         if (sys::exists(buf)) {
2868                                 existing++;
2869                         }
2870
2871                 }
2872
2873                 if (existing == 0) {
2874                         break;
2875                 }
2876
2877                 if (cnt > limit) {
2878                         error << string_compose(
2879                                         _("There are already %1 recordings for %2, which I consider too many."),
2880                                         limit, base) << endmsg;
2881                         destroy ();
2882                         throw failed_constructor();
2883                 }
2884         }
2885
2886         return Glib::path_get_basename(buf);
2887 }
2888
2889 /** Create a new within-session audio source */
2890 boost::shared_ptr<AudioFileSource>
2891 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
2892 {
2893         const string name    = new_audio_source_name (n, n_chans, chan, destructive);
2894         const string path    = new_source_path_from_name(DataType::AUDIO, name);
2895
2896         return boost::dynamic_pointer_cast<AudioFileSource> (
2897                 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
2898 }
2899
2900 /** Return a unique name based on \a base for a new internal MIDI source */
2901 string
2902 Session::new_midi_source_name (const string& base)
2903 {
2904         uint32_t cnt;
2905         char buf[PATH_MAX+1];
2906         const uint32_t limit = 10000;
2907         string legalized;
2908
2909         buf[0] = '\0';
2910         legalized = legalize_for_path (base);
2911
2912         // Find a "version" of the file name that doesn't exist in any of the possible directories.
2913         for (cnt = 1; cnt <= limit; ++cnt) {
2914
2915                 vector<space_and_path>::iterator i;
2916                 uint32_t existing = 0;
2917
2918                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2919
2920                         SessionDirectory sdir((*i).path);
2921
2922                         sys::path p = sdir.midi_path();
2923                         p /= legalized;
2924
2925                         snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
2926
2927                         if (sys::exists (buf)) {
2928                                 existing++;
2929                         }
2930                 }
2931
2932                 if (existing == 0) {
2933                         break;
2934                 }
2935
2936                 if (cnt > limit) {
2937                         error << string_compose(
2938                                         _("There are already %1 recordings for %2, which I consider too many."),
2939                                         limit, base) << endmsg;
2940                         destroy ();
2941                         throw failed_constructor();
2942                 }
2943         }
2944
2945         return Glib::path_get_basename(buf);
2946 }
2947
2948
2949 /** Create a new within-session MIDI source */
2950 boost::shared_ptr<MidiSource>
2951 Session::create_midi_source_for_session (string const & n)
2952 {
2953         const string name = new_midi_source_name (n);
2954         const string path = new_source_path_from_name (DataType::MIDI, name);
2955
2956         return boost::dynamic_pointer_cast<SMFSource> (
2957                         SourceFactory::createWritable (
2958                                         DataType::MIDI, *this, path, false, frame_rate()));
2959 }
2960
2961
2962 void
2963 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
2964 {
2965         if (playlist->hidden()) {
2966                 return;
2967         }
2968
2969         playlists->add (playlist);
2970
2971         if (unused) {
2972                 playlist->release();
2973         }
2974
2975         set_dirty();
2976 }
2977
2978 void
2979 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
2980 {
2981         if (_state_of_the_state & Deletion) {
2982                 return;
2983         }
2984
2985         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
2986
2987         if (!playlist) {
2988                 return;
2989         }
2990
2991         playlists->remove (playlist);
2992
2993         set_dirty();
2994 }
2995
2996 void
2997 Session::set_audition (boost::shared_ptr<Region> r)
2998 {
2999         pending_audition_region = r;
3000         add_post_transport_work (PostTransportAudition);
3001         _butler->schedule_transport_work ();
3002 }
3003
3004 void
3005 Session::audition_playlist ()
3006 {
3007         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3008         ev->region.reset ();
3009         queue_event (ev);
3010 }
3011
3012 void
3013 Session::non_realtime_set_audition ()
3014 {
3015         if (!pending_audition_region) {
3016                 auditioner->audition_current_playlist ();
3017         } else {
3018                 auditioner->audition_region (pending_audition_region);
3019                 pending_audition_region.reset ();
3020         }
3021         AuditionActive (true); /* EMIT SIGNAL */
3022 }
3023
3024 void
3025 Session::audition_region (boost::shared_ptr<Region> r)
3026 {
3027         SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3028         ev->region = r;
3029         queue_event (ev);
3030 }
3031
3032 void
3033 Session::cancel_audition ()
3034 {
3035         if (auditioner->auditioning()) {
3036                 auditioner->cancel_audition ();
3037                 AuditionActive (false); /* EMIT SIGNAL */
3038         }
3039 }
3040
3041 bool
3042 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3043 {
3044         if (a->is_monitor()) {
3045                 return true;
3046         }
3047         if (b->is_monitor()) {
3048                 return false;
3049         }
3050         return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3051 }
3052
3053 void
3054 Session::remove_empty_sounds ()
3055 {
3056         vector<string> audio_filenames;
3057
3058         get_files_in_directory (_session_dir->sound_path(), audio_filenames);
3059
3060         Glib::Mutex::Lock lm (source_lock);
3061
3062         TapeFileMatcher tape_file_matcher;
3063
3064         remove_if (audio_filenames.begin(), audio_filenames.end(),
3065                    boost::bind (&TapeFileMatcher::matches, &tape_file_matcher, _1));
3066
3067         for (vector<string>::iterator i = audio_filenames.begin(); i != audio_filenames.end(); ++i) {
3068
3069                 sys::path audio_file_path (_session_dir->sound_path());
3070
3071                 audio_file_path /= *i;
3072
3073                 if (AudioFileSource::is_empty (*this, audio_file_path.to_string())) {
3074
3075                         try
3076                         {
3077                                 sys::remove (audio_file_path);
3078                                 const string peakfile = peak_path (audio_file_path.to_string());
3079                                 sys::remove (peakfile);
3080                         }
3081                         catch (const sys::filesystem_error& err)
3082                         {
3083                                 error << err.what() << endmsg;
3084                         }
3085                 }
3086         }
3087 }
3088
3089 bool
3090 Session::is_auditioning () const
3091 {
3092         /* can be called before we have an auditioner object */
3093         if (auditioner) {
3094                 return auditioner->auditioning();
3095         } else {
3096                 return false;
3097         }
3098 }
3099
3100 void
3101 Session::graph_reordered ()
3102 {
3103         /* don't do this stuff if we are setting up connections
3104            from a set_state() call or creating new tracks. Ditto for deletion.
3105         */
3106
3107         if (_state_of_the_state & (InitialConnecting|Deletion)) {
3108                 return;
3109         }
3110
3111         /* every track/bus asked for this to be handled but it was deferred because
3112            we were connecting. do it now.
3113         */
3114
3115         request_input_change_handling ();
3116
3117         resort_routes ();
3118
3119         /* force all diskstreams to update their capture offset values to
3120            reflect any changes in latencies within the graph.
3121         */
3122
3123         boost::shared_ptr<RouteList> rl = routes.reader ();
3124         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3125                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3126                 if (tr) {
3127                         tr->set_capture_offset ();
3128                 }
3129         }
3130 }
3131
3132 nframes_t
3133 Session::available_capture_duration ()
3134 {
3135         float sample_bytes_on_disk = 4.0; // keep gcc happy
3136
3137         switch (config.get_native_file_data_format()) {
3138         case FormatFloat:
3139                 sample_bytes_on_disk = 4.0;
3140                 break;
3141
3142         case FormatInt24:
3143                 sample_bytes_on_disk = 3.0;
3144                 break;
3145
3146         case FormatInt16:
3147                 sample_bytes_on_disk = 2.0;
3148                 break;
3149
3150         default:
3151                 /* impossible, but keep some gcc versions happy */
3152                 fatal << string_compose (_("programming error: %1"),
3153                                          X_("illegal native file data format"))
3154                       << endmsg;
3155                 /*NOTREACHED*/
3156         }
3157
3158         double scale = 4096.0 / sample_bytes_on_disk;
3159
3160         if (_total_free_4k_blocks * scale > (double) max_frames) {
3161                 return max_frames;
3162         }
3163
3164         return (nframes_t) floor (_total_free_4k_blocks * scale);
3165 }
3166
3167 void
3168 Session::add_bundle (shared_ptr<Bundle> bundle)
3169 {
3170         {
3171                 RCUWriter<BundleList> writer (_bundles);
3172                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3173                 b->push_back (bundle);
3174         }
3175
3176         BundleAdded (bundle); /* EMIT SIGNAL */
3177
3178         set_dirty();
3179 }
3180
3181 void
3182 Session::remove_bundle (shared_ptr<Bundle> bundle)
3183 {
3184         bool removed = false;
3185
3186         {
3187                 RCUWriter<BundleList> writer (_bundles);
3188                 boost::shared_ptr<BundleList> b = writer.get_copy ();
3189                 BundleList::iterator i = find (b->begin(), b->end(), bundle);
3190
3191                 if (i != b->end()) {
3192                         b->erase (i);
3193                         removed = true;
3194                 }
3195         }
3196
3197         if (removed) {
3198                  BundleRemoved (bundle); /* EMIT SIGNAL */
3199         }
3200
3201         set_dirty();
3202 }
3203
3204 shared_ptr<Bundle>
3205 Session::bundle_by_name (string name) const
3206 {
3207         boost::shared_ptr<BundleList> b = _bundles.reader ();
3208
3209         for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
3210                 if ((*i)->name() == name) {
3211                         return* i;
3212                 }
3213         }
3214
3215         return boost::shared_ptr<Bundle> ();
3216 }
3217
3218 void
3219 Session::tempo_map_changed (const PropertyChange&)
3220 {
3221         clear_clicks ();
3222
3223         playlists->update_after_tempo_map_change ();
3224
3225         set_dirty ();
3226 }
3227
3228 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3229  * the given count with the current block size.
3230  */
3231 void
3232 Session::ensure_buffers (ChanCount howmany)
3233 {
3234         BufferManager::ensure_buffers (howmany);
3235 }
3236
3237 void
3238 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
3239 {
3240         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3241                 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
3242         }
3243 }
3244
3245 uint32_t
3246 Session::next_insert_id ()
3247 {
3248         /* this doesn't really loop forever. just think about it */
3249
3250         while (true) {
3251                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3252                         if (!insert_bitset[n]) {
3253                                 insert_bitset[n] = true;
3254                                 return n;
3255
3256                         }
3257                 }
3258
3259                 /* none available, so resize and try again */
3260
3261                 insert_bitset.resize (insert_bitset.size() + 16, false);
3262         }
3263 }
3264
3265 uint32_t
3266 Session::next_send_id ()
3267 {
3268         /* this doesn't really loop forever. just think about it */
3269
3270         while (true) {
3271                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3272                         if (!send_bitset[n]) {
3273                                 send_bitset[n] = true;
3274                                 return n;
3275
3276                         }
3277                 }
3278
3279                 /* none available, so resize and try again */
3280
3281                 send_bitset.resize (send_bitset.size() + 16, false);
3282         }
3283 }
3284
3285 uint32_t
3286 Session::next_return_id ()
3287 {
3288         /* this doesn't really loop forever. just think about it */
3289
3290         while (true) {
3291                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
3292                         if (!return_bitset[n]) {
3293                                 return_bitset[n] = true;
3294                                 return n;
3295
3296                         }
3297                 }
3298
3299                 /* none available, so resize and try again */
3300
3301                 return_bitset.resize (return_bitset.size() + 16, false);
3302         }
3303 }
3304
3305 void
3306 Session::mark_send_id (uint32_t id)
3307 {
3308         if (id >= send_bitset.size()) {
3309                 send_bitset.resize (id+16, false);
3310         }
3311         if (send_bitset[id]) {
3312                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3313         }
3314         send_bitset[id] = true;
3315 }
3316
3317 void
3318 Session::mark_return_id (uint32_t id)
3319 {
3320         if (id >= return_bitset.size()) {
3321                 return_bitset.resize (id+16, false);
3322         }
3323         if (return_bitset[id]) {
3324                 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
3325         }
3326         return_bitset[id] = true;
3327 }
3328
3329 void
3330 Session::mark_insert_id (uint32_t id)
3331 {
3332         if (id >= insert_bitset.size()) {
3333                 insert_bitset.resize (id+16, false);
3334         }
3335         if (insert_bitset[id]) {
3336                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3337         }
3338         insert_bitset[id] = true;
3339 }
3340
3341 void
3342 Session::unmark_send_id (uint32_t id)
3343 {
3344         if (id < send_bitset.size()) {
3345                 send_bitset[id] = false;
3346         }
3347 }
3348
3349 void
3350 Session::unmark_return_id (uint32_t id)
3351 {
3352         if (id < return_bitset.size()) {
3353                 return_bitset[id] = false;
3354         }
3355 }
3356
3357 void
3358 Session::unmark_insert_id (uint32_t id)
3359 {
3360         if (id < insert_bitset.size()) {
3361                 insert_bitset[id] = false;
3362         }
3363 }
3364
3365
3366 /* Named Selection management */
3367
3368 boost::shared_ptr<NamedSelection>
3369 Session::named_selection_by_name (string name)
3370 {
3371         Glib::Mutex::Lock lm (named_selection_lock);
3372         for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3373                 if ((*i)->name == name) {
3374                         return *i;
3375                 }
3376         }
3377         return boost::shared_ptr<NamedSelection>();
3378 }
3379
3380 void
3381 Session::add_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3382 {
3383         {
3384                 Glib::Mutex::Lock lm (named_selection_lock);
3385                 named_selections.insert (named_selections.begin(), named_selection);
3386         }
3387
3388         set_dirty();
3389
3390         NamedSelectionAdded (); /* EMIT SIGNAL */
3391 }
3392
3393 void
3394 Session::remove_named_selection (boost::shared_ptr<NamedSelection> named_selection)
3395 {
3396         bool removed = false;
3397
3398         {
3399                 Glib::Mutex::Lock lm (named_selection_lock);
3400
3401                 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3402
3403                 if (i != named_selections.end()) {
3404                         named_selections.erase (i);
3405                         set_dirty();
3406                         removed = true;
3407                 }
3408         }
3409
3410         if (removed) {
3411                  NamedSelectionRemoved (); /* EMIT SIGNAL */
3412         }
3413 }
3414
3415 void
3416 Session::reset_native_file_format ()
3417 {
3418         boost::shared_ptr<RouteList> rl = routes.reader ();
3419         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3420                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3421                 if (tr) {
3422                         tr->reset_write_sources (false);
3423                 }
3424         }
3425 }
3426
3427 bool
3428 Session::route_name_unique (string n) const
3429 {
3430         shared_ptr<RouteList> r = routes.reader ();
3431
3432         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3433                 if ((*i)->name() == n) {
3434                         return false;
3435                 }
3436         }
3437
3438         return true;
3439 }
3440
3441 bool
3442 Session::route_name_internal (string n) const
3443 {
3444         if (auditioner && auditioner->name() == n) {
3445                 return true;
3446         }
3447
3448         if (_click_io && _click_io->name() == n) {
3449                 return true;
3450         }
3451
3452         return false;
3453 }
3454
3455 int
3456 Session::freeze_all (InterThreadInfo& itt)
3457 {
3458         shared_ptr<RouteList> r = routes.reader ();
3459
3460         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3461
3462                 boost::shared_ptr<Track> t;
3463
3464                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
3465                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3466                            of every track.
3467                         */
3468                         t->freeze_me (itt);
3469                 }
3470         }
3471
3472         return 0;
3473 }
3474
3475 boost::shared_ptr<Region>
3476 Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
3477                           bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
3478                           InterThreadInfo& itt, bool enable_processing)
3479 {
3480         boost::shared_ptr<Region> result;
3481         boost::shared_ptr<Playlist> playlist;
3482         boost::shared_ptr<AudioFileSource> fsource;
3483         uint32_t x;
3484         char buf[PATH_MAX+1];
3485         ChanCount nchans(track.n_channels());
3486         nframes_t position;
3487         nframes_t this_chunk;
3488         nframes_t to_do;
3489         BufferSet buffers;
3490         SessionDirectory sdir(get_best_session_directory_for_new_source ());
3491         const string sound_dir = sdir.sound_path().to_string();
3492         nframes_t len = end - start;
3493
3494         if (end <= start) {
3495                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
3496                                          end, start) << endmsg;
3497                 return result;
3498         }
3499
3500         const nframes_t chunk_size = (256 * 1024)/4;
3501
3502         // block all process callback handling
3503
3504         block_processing ();
3505
3506         /* call tree *MUST* hold route_lock */
3507
3508         if ((playlist = track.playlist()) == 0) {
3509                 goto out;
3510         }
3511
3512         /* external redirects will be a problem */
3513
3514         if (track.has_external_redirects()) {
3515                 goto out;
3516         }
3517
3518         for (uint32_t chan_n=0; chan_n < nchans.n_audio(); ++chan_n) {
3519
3520                 for (x = 0; x < 99999; ++x) {
3521                         snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1);
3522                         if (access (buf, F_OK) != 0) {
3523                                 break;
3524                         }
3525                 }
3526
3527                 if (x == 99999) {
3528                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3529                         goto out;
3530                 }
3531
3532                 try {
3533                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (
3534                                 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
3535                 }
3536
3537                 catch (failed_constructor& err) {
3538                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3539                         goto out;
3540                 }
3541
3542                 srcs.push_back (fsource);
3543         }
3544
3545         /* XXX need to flush all redirects */
3546
3547         position = start;
3548         to_do = len;
3549
3550         /* create a set of reasonably-sized buffers */
3551         buffers.ensure_buffers(DataType::AUDIO, nchans.n_audio(), chunk_size);
3552         buffers.set_count(nchans);
3553
3554         for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3555                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3556                 if (afs)
3557                         afs->prepare_for_peakfile_writes ();
3558         }
3559
3560         while (to_do && !itt.cancel) {
3561
3562                 this_chunk = min (to_do, chunk_size);
3563
3564                 if (track.export_stuff (buffers, start, this_chunk, enable_processing)) {
3565                         goto out;
3566                 }
3567
3568                 uint32_t n = 0;
3569                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3570                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3571
3572                         if (afs) {
3573                                 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
3574                                         goto out;
3575                                 }
3576                         }
3577                 }
3578
3579                 start += this_chunk;
3580                 to_do -= this_chunk;
3581
3582                 itt.progress = (float) (1.0 - ((double) to_do / len));
3583
3584         }
3585
3586         if (!itt.cancel) {
3587
3588                 time_t now;
3589                 struct tm* xnow;
3590                 time (&now);
3591                 xnow = localtime (&now);
3592
3593                 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3594                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3595
3596                         if (afs) {
3597                                 afs->update_header (position, *xnow, now);
3598                                 afs->flush_header ();
3599                         }
3600                 }
3601
3602                 /* construct a region to represent the bounced material */
3603
3604                 PropertyList plist;
3605
3606                 plist.add (Properties::start, 0);
3607                 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
3608                 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
3609
3610                 result = RegionFactory::create (srcs, plist);
3611
3612         }
3613
3614   out:
3615         if (!result) {
3616                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3617                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3618
3619                         if (afs) {
3620                                 afs->mark_for_remove ();
3621                         }
3622
3623                         (*src)->drop_references ();
3624                 }
3625
3626         } else {
3627                 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3628                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3629
3630                         if (afs)
3631                                 afs->done_with_peakfile_writes ();
3632                 }
3633         }
3634
3635         unblock_processing ();
3636
3637         return result;
3638 }
3639
3640 gain_t*
3641 Session::gain_automation_buffer() const
3642 {
3643         return ProcessThread::gain_automation_buffer ();
3644 }
3645
3646 pan_t**
3647 Session::pan_automation_buffer() const
3648 {
3649         return ProcessThread::pan_automation_buffer ();
3650 }
3651
3652 BufferSet&
3653 Session::get_silent_buffers (ChanCount count)
3654 {
3655         return ProcessThread::get_silent_buffers (count);
3656 #if 0
3657         assert(_silent_buffers->available() >= count);
3658         _silent_buffers->set_count(count);
3659
3660         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3661                 for (size_t i= 0; i < count.get(*t); ++i) {
3662                         _silent_buffers->get(*t, i).clear();
3663                 }
3664         }
3665
3666         return *_silent_buffers;
3667 #endif
3668 }
3669
3670 BufferSet&
3671 Session::get_scratch_buffers (ChanCount count)
3672 {
3673         return ProcessThread::get_scratch_buffers (count);
3674 #if 0
3675         if (count != ChanCount::ZERO) {
3676                 assert(_scratch_buffers->available() >= count);
3677                 _scratch_buffers->set_count(count);
3678         } else {
3679                 _scratch_buffers->set_count (_scratch_buffers->available());
3680         }
3681
3682         return *_scratch_buffers;
3683 #endif
3684 }
3685
3686 BufferSet&
3687 Session::get_mix_buffers (ChanCount count)
3688 {
3689         return ProcessThread::get_mix_buffers (count);
3690 #if 0
3691         assert(_mix_buffers->available() >= count);
3692         _mix_buffers->set_count(count);
3693         return *_mix_buffers;
3694 #endif
3695 }
3696
3697 uint32_t
3698 Session::ntracks () const
3699 {
3700         uint32_t n = 0;
3701         shared_ptr<RouteList> r = routes.reader ();
3702
3703         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3704                 if (boost::dynamic_pointer_cast<Track> (*i)) {
3705                         ++n;
3706                 }
3707         }
3708
3709         return n;
3710 }
3711
3712 uint32_t
3713 Session::nbusses () const
3714 {
3715         uint32_t n = 0;
3716         shared_ptr<RouteList> r = routes.reader ();
3717
3718         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3719                 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
3720                         ++n;
3721                 }
3722         }
3723
3724         return n;
3725 }
3726
3727 void
3728 Session::add_automation_list(AutomationList *al)
3729 {
3730         automation_lists[al->id()] = al;
3731 }
3732
3733 void
3734 Session::sync_order_keys (std::string const & base)
3735 {
3736         if (deletion_in_progress()) {
3737                 return;
3738         }
3739
3740         if (!Config->get_sync_all_route_ordering()) {
3741                 /* leave order keys as they are */
3742                 return;
3743         }
3744
3745         boost::shared_ptr<RouteList> r = routes.reader ();
3746
3747         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3748                 (*i)->sync_order_keys (base);
3749         }
3750
3751         Route::SyncOrderKeys (base); // EMIT SIGNAL
3752
3753         /* this might not do anything */
3754
3755         set_remote_control_ids ();
3756 }
3757
3758 /** @return true if there is at least one record-enabled track, otherwise false */
3759 bool
3760 Session::have_rec_enabled_track () const
3761 {
3762         return g_atomic_int_get (&_have_rec_enabled_track) == 1;
3763 }
3764
3765 /** Update the state of our rec-enabled tracks flag */
3766 void
3767 Session::update_have_rec_enabled_track ()
3768 {
3769         boost::shared_ptr<RouteList> rl = routes.reader ();
3770         RouteList::iterator i = rl->begin();
3771         while (i != rl->end ()) {
3772
3773                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3774                 if (tr && tr->record_enabled ()) {
3775                         break;
3776                 }
3777
3778                 ++i;
3779         }
3780
3781         int const old = g_atomic_int_get (&_have_rec_enabled_track);
3782
3783         g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
3784
3785         if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
3786                 RecordStateChanged (); /* EMIT SIGNAL */
3787         }
3788 }
3789
3790 void
3791 Session::listen_position_changed ()
3792 {
3793         Placement p;
3794
3795         switch (Config->get_listen_position()) {
3796         case AfterFaderListen:
3797                 p = PostFader;
3798                 break;
3799
3800         case PreFaderListen:
3801                 p = PreFader;
3802                 break;
3803         }
3804
3805         boost::shared_ptr<RouteList> r = routes.reader ();
3806
3807         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3808                 (*i)->put_monitor_send_at (p);
3809         }
3810 }
3811
3812 void
3813 Session::solo_control_mode_changed ()
3814 {
3815         /* cancel all solo or all listen when solo control mode changes */
3816
3817         if (soloing()) {
3818                 set_solo (get_routes(), false);
3819         } else if (listening()) {
3820                 set_listen (get_routes(), false);
3821         }
3822 }
3823
3824 void
3825 Session::route_group_changed ()
3826 {
3827         RouteGroupChanged (); /* EMIT SIGNAL */
3828 }
3829
3830 vector<SyncSource>
3831 Session::get_available_sync_options () const
3832 {
3833         vector<SyncSource> ret;
3834
3835         ret.push_back (JACK);
3836
3837         if (mtc_port()) {
3838                 ret.push_back (MTC);
3839         }
3840
3841         if (midi_clock_port()) {
3842                 ret.push_back (MIDIClock);
3843         }
3844
3845         return ret;
3846 }
3847
3848 boost::shared_ptr<RouteList>
3849 Session::get_routes_with_regions_at (nframes64_t const p) const
3850 {
3851         shared_ptr<RouteList> r = routes.reader ();
3852         shared_ptr<RouteList> rl (new RouteList);
3853
3854         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3855                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3856                 if (!tr) {
3857                         continue;
3858                 }
3859
3860                 boost::shared_ptr<Playlist> pl = tr->playlist ();
3861                 if (!pl) {
3862                         continue;
3863                 }
3864
3865                 if (pl->has_region_at (p)) {
3866                         rl->push_back (*i);
3867                 }
3868         }
3869
3870         return rl;
3871 }
3872
3873 void
3874 Session::goto_end ()
3875 {
3876         if (_session_range_location) {
3877                 request_locate (_session_range_location->end(), false);
3878         } else {
3879                 request_locate (0, false);
3880         }
3881 }
3882
3883 void
3884 Session::goto_start ()
3885 {
3886         if (_session_range_location) {
3887                 request_locate (_session_range_location->start(), false);
3888         } else {
3889                 request_locate (0, false);
3890         }
3891 }
3892
3893 void
3894 Session::set_session_start (nframes_t start)
3895 {
3896         if (_session_range_location) {
3897                 _session_range_location->set_start (start);
3898         } else {
3899                 add_session_range_location (start, start);
3900         }
3901 }
3902
3903 void
3904 Session::set_session_end (nframes_t end)
3905 {
3906         if (_session_range_location) {
3907                 _session_range_location->set_end (end);
3908         } else {
3909                 add_session_range_location (end, end);
3910         }
3911 }
3912
3913 nframes_t
3914 Session::current_start_frame () const
3915 {
3916         return _session_range_location ? _session_range_location->start() : 0;
3917 }
3918
3919 nframes_t
3920 Session::current_end_frame () const
3921 {
3922         return _session_range_location ? _session_range_location->end() : 0;
3923 }
3924
3925 void
3926 Session::add_session_range_location (nframes_t start, nframes_t end)
3927 {
3928         _session_range_location = new Location (start, end, _("session"), Location::IsSessionRange);
3929         _locations.add (_session_range_location);
3930 }