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