libs/ardour/session.cc

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