libs/ardour/session.cc

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