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