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