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