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