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