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