libs/ardour/session.cc

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