libs/ardour/session.cc

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