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