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 && non_realtime_work_pending()) {
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         /* this is where we actually implement solo by changing
2306            the solo mute setting of each track.
2307         */
2308
2309         shared_ptr<RouteList> r = routes.reader ();
2310
2311         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2312                 if ((*i)->soloed()) {
2313                         mute = true;
2314                         if (dynamic_cast<AudioTrack*>((*i).get())) {
2315                                 is_track = true;
2316                         }
2317                         break;
2318                 }
2319         }
2320
2321         if (mute != currently_soloing) {
2322                 signal = true;
2323                 currently_soloing = mute;
2324         }
2325
2326         if (!is_track && !mute) {
2327
2328                 /* nothing is soloed */
2329
2330                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2331                         (*i)->set_solo_mute (false);
2332                 }
2333
2334                 if (signal) {
2335                         SoloActive (false);
2336                 }
2337
2338                 return;
2339         }
2340
2341         modify_solo_mute (is_track, mute);
2342
2343         if (signal) {
2344                 SoloActive (currently_soloing);
2345         }
2346 }
2347
2348 void
2349 Session::modify_solo_mute (bool is_track, bool mute)
2350 {
2351         shared_ptr<RouteList> r = routes.reader ();
2352
2353         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2354
2355                 if (is_track) {
2356
2357                         /* only alter track solo mute */
2358
2359                         if (dynamic_cast<AudioTrack*>((*i).get())) {
2360                                 if ((*i)->soloed()) {
2361                                         (*i)->set_solo_mute (!mute);
2362                                 } else {
2363                                         (*i)->set_solo_mute (mute);
2364                                 }
2365                         }
2366
2367                 } else {
2368
2369                         /* only alter bus solo mute */
2370
2371                         if (!dynamic_cast<AudioTrack*>((*i).get())) {
2372
2373                                 if ((*i)->soloed()) {
2374
2375                                         (*i)->set_solo_mute (false);
2376
2377                                 } else {
2378
2379                                         /* don't mute master or control outs
2380                                            in response to another bus solo
2381                                         */
2382
2383                                         if ((*i) != _master_out &&
2384                                             (*i) != _control_out) {
2385                                                 (*i)->set_solo_mute (mute);
2386                                         }
2387                                 }
2388                         }
2389
2390                 }
2391         }
2392 }
2393
2394
2395 void
2396 Session::catch_up_on_solo ()
2397 {
2398         /* this is called after set_state() to catch the full solo
2399            state, which can't be correctly determined on a per-route
2400            basis, but needs the global overview that only the session
2401            has.
2402         */
2403         update_route_solo_state();
2404 }
2405
2406 void
2407 Session::catch_up_on_solo_mute_override ()
2408 {
2409         /* this is called whenever the param solo-mute-override is
2410            changed.
2411         */
2412         shared_ptr<RouteList> r = routes.reader ();
2413
2414         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2415                 (*i)->catch_up_on_solo_mute_override ();
2416         }
2417 }
2418
2419 shared_ptr<Route>
2420 Session::route_by_name (string name)
2421 {
2422         shared_ptr<RouteList> r = routes.reader ();
2423
2424         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2425                 if ((*i)->name() == name) {
2426                         return *i;
2427                 }
2428         }
2429
2430         return shared_ptr<Route> ((Route*) 0);
2431 }
2432
2433 shared_ptr<Route>
2434 Session::route_by_id (PBD::ID id)
2435 {
2436         shared_ptr<RouteList> r = routes.reader ();
2437
2438         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2439                 if ((*i)->id() == id) {
2440                         return *i;
2441                 }
2442         }
2443
2444         return shared_ptr<Route> ((Route*) 0);
2445 }
2446
2447 shared_ptr<Route>
2448 Session::route_by_remote_id (uint32_t id)
2449 {
2450         shared_ptr<RouteList> r = routes.reader ();
2451
2452         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2453                 if ((*i)->remote_control_id() == id) {
2454                         return *i;
2455                 }
2456         }
2457
2458         return shared_ptr<Route> ((Route*) 0);
2459 }
2460
2461 void
2462 Session::find_current_end ()
2463 {
2464         if (_state_of_the_state & Loading) {
2465                 return;
2466         }
2467
2468         nframes_t max = get_maximum_extent ();
2469
2470         if (max > end_location->end()) {
2471                 end_location->set_end (max);
2472                 set_dirty();
2473                 DurationChanged(); /* EMIT SIGNAL */
2474         }
2475 }
2476
2477 nframes_t
2478 Session::get_maximum_extent () const
2479 {
2480         nframes_t max = 0;
2481         nframes_t me;
2482
2483         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2484
2485         for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
2486                 if ((*i)->destructive())  //ignore tape tracks when getting max extents
2487                         continue;
2488                 boost::shared_ptr<Playlist> pl = (*i)->playlist();
2489                 if ((me = pl->get_maximum_extent()) > max) {
2490                         max = me;
2491                 }
2492         }
2493
2494         return max;
2495 }
2496
2497 boost::shared_ptr<Diskstream>
2498 Session::diskstream_by_name (string name)
2499 {
2500         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2501
2502         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2503                 if ((*i)->name() == name) {
2504                         return *i;
2505                 }
2506         }
2507
2508         return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2509 }
2510
2511 boost::shared_ptr<Diskstream>
2512 Session::diskstream_by_id (const PBD::ID& id)
2513 {
2514         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2515
2516         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2517                 if ((*i)->id() == id) {
2518                         return *i;
2519                 }
2520         }
2521
2522         return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2523 }
2524
2525 /* AudioRegion management */
2526
2527 string
2528 Session::new_region_name (string old)
2529 {
2530         string::size_type last_period;
2531         uint32_t number;
2532         string::size_type len = old.length() + 64;
2533         char buf[len];
2534
2535         if ((last_period = old.find_last_of ('.')) == string::npos) {
2536
2537                 /* no period present - add one explicitly */
2538
2539                 old += '.';
2540                 last_period = old.length() - 1;
2541                 number = 0;
2542
2543         } else {
2544
2545                 number = atoi (old.substr (last_period+1).c_str());
2546
2547         }
2548
2549         while (number < (UINT_MAX-1)) {
2550
2551                 AudioRegionList::const_iterator i;
2552                 string sbuf;
2553
2554                 number++;
2555
2556                 snprintf (buf, len, "%s%" PRIu32, old.substr (0, last_period + 1).c_str(), number);
2557                 sbuf = buf;
2558
2559                 for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2560                         if (i->second->name() == sbuf) {
2561                                 break;
2562                         }
2563                 }
2564
2565                 if (i == audio_regions.end()) {
2566                         break;
2567                 }
2568         }
2569
2570         if (number != (UINT_MAX-1)) {
2571                 return buf;
2572         }
2573
2574         error << string_compose (_("cannot create new name for region \"%1\""), old) << endmsg;
2575         return old;
2576 }
2577
2578 int
2579 Session::region_name (string& result, string base, bool newlevel)
2580 {
2581         char buf[16];
2582         string subbase;
2583
2584         if (base == "") {
2585
2586                 Glib::Mutex::Lock lm (region_lock);
2587
2588                 snprintf (buf, sizeof (buf), "%d", (int)audio_regions.size() + 1);
2589                 result = "region.";
2590                 result += buf;
2591
2592         } else {
2593
2594                 if (newlevel) {
2595                         subbase = base;
2596                 } else {
2597                         string::size_type pos;
2598
2599                         pos = base.find_last_of ('.');
2600
2601                         /* pos may be npos, but then we just use entire base */
2602
2603                         subbase = base.substr (0, pos);
2604
2605                 }
2606
2607                 {
2608                         Glib::Mutex::Lock lm (region_lock);
2609
2610                         map<string,uint32_t>::iterator x;
2611
2612                         result = subbase;
2613
2614                         if ((x = region_name_map.find (subbase)) == region_name_map.end()) {
2615                                 result += ".1";
2616                                 region_name_map[subbase] = 1;
2617                         } else {
2618                                 x->second++;
2619                                 snprintf (buf, sizeof (buf), ".%d", x->second);
2620                                 result += buf;
2621                         }
2622                 }
2623         }
2624
2625         return 0;
2626 }
2627
2628 void
2629 Session::add_region (boost::shared_ptr<Region> region)
2630 {
2631         vector<boost::shared_ptr<Region> > v;
2632         v.push_back (region);
2633         add_regions (v);
2634 }
2635
2636 void
2637 Session::add_regions (vector<boost::shared_ptr<Region> >& new_regions)
2638 {
2639         boost::shared_ptr<AudioRegion> ar;
2640         boost::shared_ptr<AudioRegion> oar;
2641         bool added = false;
2642
2643         {
2644                 Glib::Mutex::Lock lm (region_lock);
2645
2646                 for (vector<boost::shared_ptr<Region> >::iterator ii = new_regions.begin(); ii != new_regions.end(); ++ii) {
2647
2648                         boost::shared_ptr<Region> region = *ii;
2649
2650                         if (region == 0) {
2651
2652                                 error << _("Session::add_region() ignored a null region. Warning: you might have lost a region.") << endmsg;
2653
2654                         } else if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2655
2656                                 AudioRegionList::iterator x;
2657
2658                                 for (x = audio_regions.begin(); x != audio_regions.end(); ++x) {
2659
2660                                         oar = boost::dynamic_pointer_cast<AudioRegion> (x->second);
2661
2662                                         if (ar->region_list_equivalent (oar)) {
2663                                                 break;
2664                                         }
2665                                 }
2666
2667                                 if (x == audio_regions.end()) {
2668
2669                                         pair<AudioRegionList::key_type,AudioRegionList::mapped_type> entry;
2670
2671                                         entry.first = region->id();
2672                                         entry.second = ar;
2673
2674                                         pair<AudioRegionList::iterator,bool> x = audio_regions.insert (entry);
2675
2676                                         if (!x.second) {
2677                                                 return;
2678                                         }
2679
2680                                         added = true;
2681                                 }
2682
2683                         } else {
2684
2685                                 fatal << _("programming error: ")
2686                                       << X_("unknown region type passed to Session::add_region()")
2687                                       << endmsg;
2688                                 /*NOTREACHED*/
2689
2690                         }
2691                 }
2692         }
2693
2694         /* mark dirty because something has changed even if we didn't
2695            add the region to the region list.
2696         */
2697
2698         set_dirty ();
2699
2700         if (added) {
2701
2702                 vector<boost::weak_ptr<AudioRegion> > v;
2703                 boost::shared_ptr<AudioRegion> first_ar;
2704
2705                 for (vector<boost::shared_ptr<Region> >::iterator ii = new_regions.begin(); ii != new_regions.end(); ++ii) {
2706
2707                         boost::shared_ptr<Region> region = *ii;
2708                         boost::shared_ptr<AudioRegion> ar;
2709
2710                         if (region == 0) {
2711
2712                                 error << _("Session::add_region() ignored a null region. Warning: you might have lost a region.") << endmsg;
2713
2714                         } else if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2715                                 v.push_back (ar);
2716
2717                                 if (!first_ar) {
2718                                         first_ar = ar;
2719                                 }
2720                         }
2721
2722                         region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
2723                         region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
2724
2725                         update_region_name_map (region);
2726                 }
2727
2728                 if (!v.empty()) {
2729                         AudioRegionsAdded (v); /* EMIT SIGNAL */
2730                 }
2731         }
2732 }
2733
2734 void
2735 Session::update_region_name_map (boost::shared_ptr<Region> region)
2736 {
2737         string::size_type last_period = region->name().find_last_of ('.');
2738
2739         if (last_period != string::npos && last_period < region->name().length() - 1) {
2740
2741                 string base = region->name().substr (0, last_period);
2742                 string number = region->name().substr (last_period+1);
2743                 map<string,uint32_t>::iterator x;
2744
2745                 /* note that if there is no number, we get zero from atoi,
2746                    which is just fine
2747                 */
2748
2749                 region_name_map[base] = atoi (number);
2750         }
2751 }
2752
2753 void
2754 Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_region)
2755 {
2756         boost::shared_ptr<Region> region (weak_region.lock ());
2757
2758         if (!region) {
2759                 return;
2760         }
2761
2762         if (what_changed & Region::HiddenChanged) {
2763                 /* relay hidden changes */
2764                 RegionHiddenChange (region);
2765         }
2766
2767         if (what_changed & NameChanged) {
2768                 update_region_name_map (region);
2769         }
2770 }
2771
2772 void
2773 Session::remove_region (boost::weak_ptr<Region> weak_region)
2774 {
2775         AudioRegionList::iterator i;
2776         boost::shared_ptr<Region> region (weak_region.lock ());
2777
2778         if (!region) {
2779                 return;
2780         }
2781
2782         boost::shared_ptr<AudioRegion> ar;
2783         bool removed = false;
2784
2785         {
2786                 Glib::Mutex::Lock lm (region_lock);
2787
2788                 if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2789                         if ((i = audio_regions.find (region->id())) != audio_regions.end()) {
2790                                 audio_regions.erase (i);
2791                                 removed = true;
2792                         }
2793
2794                 } else {
2795
2796                         fatal << _("programming error: ")
2797                               << X_("unknown region type passed to Session::remove_region()")
2798                               << endmsg;
2799                         /*NOTREACHED*/
2800                 }
2801         }
2802
2803         /* mark dirty because something has changed even if we didn't
2804            remove the region from the region list.
2805         */
2806
2807         set_dirty();
2808
2809         if (removed) {
2810                 AudioRegionRemoved (ar); /* EMIT SIGNAL */
2811         }
2812 }
2813
2814 boost::shared_ptr<AudioRegion>
2815 Session::find_whole_file_parent (boost::shared_ptr<AudioRegion const> child)
2816 {
2817         AudioRegionList::iterator i;
2818         boost::shared_ptr<AudioRegion> region;
2819         Glib::Mutex::Lock lm (region_lock);
2820
2821         for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2822
2823                 region = i->second;
2824
2825                 if (region->whole_file()) {
2826
2827                         if (child->source_equivalent (region)) {
2828                                 return region;
2829                         }
2830                 }
2831         }
2832
2833         return boost::shared_ptr<AudioRegion> ();
2834 }
2835
2836 void
2837 Session::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
2838 {
2839         for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i)
2840                 (*i)->get_region_list_equivalent_regions (region, result);
2841 }
2842
2843 int
2844 Session::destroy_region (boost::shared_ptr<Region> region)
2845 {
2846         vector<boost::shared_ptr<Source> > srcs;
2847
2848         {
2849                 boost::shared_ptr<AudioRegion> aregion;
2850
2851                 if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
2852                         return 0;
2853                 }
2854
2855                 if (aregion->playlist()) {
2856                         aregion->playlist()->destroy_region (region);
2857                 }
2858
2859                 for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
2860                         srcs.push_back (aregion->source (n));
2861                 }
2862         }
2863
2864         region->drop_references ();
2865
2866         for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
2867
2868                 if (!(*i)->used()) {
2869                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
2870
2871                         if (afs) {
2872                                 (afs)->mark_for_remove ();
2873                         }
2874
2875                         (*i)->drop_references ();
2876
2877                         cerr << "source was not used by any playlist\n";
2878                 }
2879         }
2880
2881         return 0;
2882 }
2883
2884 int
2885 Session::destroy_regions (list<boost::shared_ptr<Region> > regions)
2886 {
2887         for (list<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
2888                 destroy_region (*i);
2889         }
2890         return 0;
2891 }
2892
2893 int
2894 Session::remove_last_capture ()
2895 {
2896         list<boost::shared_ptr<Region> > r;
2897
2898         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2899
2900         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2901                 list<boost::shared_ptr<Region> >& l = (*i)->last_capture_regions();
2902
2903                 if (!l.empty()) {
2904                         r.insert (r.end(), l.begin(), l.end());
2905                         l.clear ();
2906                 }
2907         }
2908
2909         destroy_regions (r);
2910
2911         save_state (_current_snapshot_name);
2912
2913         return 0;
2914 }
2915
2916 int
2917 Session::remove_region_from_region_list (boost::shared_ptr<Region> r)
2918 {
2919         remove_region (r);
2920         return 0;
2921 }
2922
2923 /* Source Management */
2924
2925 void
2926 Session::add_source (boost::shared_ptr<Source> source)
2927 {
2928         boost::shared_ptr<AudioFileSource> afs;
2929
2930         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2931
2932                 pair<AudioSourceList::key_type, AudioSourceList::mapped_type> entry;
2933                 pair<AudioSourceList::iterator,bool> result;
2934
2935                 entry.first = source->id();
2936                 entry.second = afs;
2937
2938                 {
2939                         Glib::Mutex::Lock lm (audio_source_lock);
2940                         result = audio_sources.insert (entry);
2941                 }
2942
2943                 if (result.second) {
2944                         source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
2945                         set_dirty();
2946                 }
2947
2948                 if (Config->get_auto_analyse_audio()) {
2949                         Analyser::queue_source_for_analysis (source, false);
2950                 }
2951         }
2952 }
2953
2954 void
2955 Session::remove_source (boost::weak_ptr<Source> src)
2956 {
2957         AudioSourceList::iterator i;
2958         boost::shared_ptr<Source> source = src.lock();
2959
2960         if (!source) {
2961                 return;
2962         }
2963
2964         {
2965                 Glib::Mutex::Lock lm (audio_source_lock);
2966
2967                 if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
2968                         audio_sources.erase (i);
2969                 }
2970         }
2971
2972         if (!_state_of_the_state & InCleanup) {
2973
2974                 /* save state so we don't end up with a session file
2975                    referring to non-existent sources.
2976                 */
2977
2978                 save_state (_current_snapshot_name);
2979         }
2980 }
2981
2982 boost::shared_ptr<Source>
2983 Session::source_by_id (const PBD::ID& id)
2984 {
2985         Glib::Mutex::Lock lm (audio_source_lock);
2986         AudioSourceList::iterator i;
2987         boost::shared_ptr<Source> source;
2988
2989         if ((i = audio_sources.find (id)) != audio_sources.end()) {
2990                 source = i->second;
2991         }
2992
2993         /* XXX search MIDI or other searches here */
2994
2995         return source;
2996 }
2997
2998
2999 boost::shared_ptr<Source>
3000 Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
3001 {
3002         Glib::Mutex::Lock lm (audio_source_lock);
3003
3004         for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
3005                 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
3006
3007                 if (afs && afs->path() == path && chn == afs->channel()) {
3008                         return afs;
3009                 }
3010
3011         }
3012         return boost::shared_ptr<Source>();
3013 }
3014
3015 Glib::ustring
3016 Session::peak_path (Glib::ustring base) const
3017 {
3018         return Glib::build_filename(peak_dir (), base + ".peak");
3019 }
3020
3021 string
3022 Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
3023 {
3024         string look_for;
3025         string old_basename = PBD::basename_nosuffix (oldname);
3026         string new_legalized = legalize_for_path (newname);
3027
3028         /* note: we know (or assume) the old path is already valid */
3029
3030         if (destructive) {
3031
3032                 /* destructive file sources have a name of the form:
3033
3034                     /path/to/Tnnnn-NAME(%[LR])?.wav
3035
3036                     the task here is to replace NAME with the new name.
3037                 */
3038
3039                 /* find last slash */
3040
3041                 string dir;
3042                 string prefix;
3043                 string::size_type slash;
3044                 string::size_type dash;
3045
3046                 if ((slash = path.find_last_of ('/')) == string::npos) {
3047                         return "";
3048                 }
3049
3050                 dir = path.substr (0, slash+1);
3051
3052                 /* '-' is not a legal character for the NAME part of the path */
3053
3054                 if ((dash = path.find_last_of ('-')) == string::npos) {
3055                         return "";
3056                 }
3057
3058                 prefix = path.substr (slash+1, dash-(slash+1));
3059
3060                 path = dir;
3061                 path += prefix;
3062                 path += '-';
3063                 path += new_legalized;
3064                 path += ".wav";  /* XXX gag me with a spoon */
3065
3066         } else {
3067
3068                 /* non-destructive file sources have a name of the form:
3069
3070                     /path/to/NAME-nnnnn(%[LR])?.wav
3071
3072                     the task here is to replace NAME with the new name.
3073                 */
3074
3075                 string dir;
3076                 string suffix;
3077                 string::size_type slash;
3078                 string::size_type dash;
3079                 string::size_type postfix;
3080
3081                 /* find last slash */
3082
3083                 if ((slash = path.find_last_of ('/')) == string::npos) {
3084                         return "";
3085                 }
3086
3087                 dir = path.substr (0, slash+1);
3088
3089                 /* '-' is not a legal character for the NAME part of the path */
3090
3091                 if ((dash = path.find_last_of ('-')) == string::npos) {
3092                         return "";
3093                 }
3094
3095                 suffix = path.substr (dash+1);
3096
3097                 // Suffix is now everything after the dash. Now we need to eliminate
3098                 // the nnnnn part, which is done by either finding a '%' or a '.'
3099
3100                 postfix = suffix.find_last_of ("%");
3101                 if (postfix == string::npos) {
3102                         postfix = suffix.find_last_of ('.');
3103                 }
3104
3105                 if (postfix != string::npos) {
3106                         suffix = suffix.substr (postfix);
3107                 } else {
3108                         error << "Logic error in Session::change_audio_path_by_name(), please report to the developers" << endl;
3109                         return "";
3110                 }
3111
3112                 const uint32_t limit = 10000;
3113                 char buf[PATH_MAX+1];
3114
3115                 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3116
3117                         snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
3118
3119                         if (access (buf, F_OK) != 0) {
3120                                 path = buf;
3121                                 break;
3122                         }
3123                         path = "";
3124                 }
3125
3126                 if (path == "") {
3127                         error << "FATAL ERROR! Could not find a " << endl;
3128                 }
3129
3130         }
3131
3132         return path;
3133 }
3134
3135 string
3136 Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
3137 {
3138         string spath;
3139         uint32_t cnt;
3140         char buf[PATH_MAX+1];
3141         const uint32_t limit = 10000;
3142         string legalized;
3143
3144         buf[0] = '\0';
3145         legalized = legalize_for_path (name);
3146
3147         /* find a "version" of the file name that doesn't exist in
3148            any of the possible directories.
3149         */
3150
3151         for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3152
3153                 vector<space_and_path>::iterator i;
3154                 uint32_t existing = 0;
3155
3156                 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3157
3158                         spath = (*i).path;
3159
3160                         spath += sound_dir (false);
3161
3162                         if (destructive) {
3163                                 if (nchan < 2) {
3164                                         snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3165                                 } else if (nchan == 2) {
3166                                         if (chan == 0) {
3167                                                 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav", spath.c_str(), cnt, legalized.c_str());
3168                                         } else {
3169                                                 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav", spath.c_str(), cnt, legalized.c_str());
3170                                         }
3171                                 } else if (nchan < 26) {
3172                                         snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav", spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
3173                                 } else {
3174                                         snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3175                                 }
3176
3177                         } else {
3178
3179                                 spath += '/';
3180                                 spath += legalized;
3181
3182                                 if (nchan < 2) {
3183                                         snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3184                                 } else if (nchan == 2) {
3185                                         if (chan == 0) {
3186                                                 snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
3187                                         } else {
3188                                                 snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
3189                                         }
3190                                 } else if (nchan < 26) {
3191                                         snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
3192                                 } else {
3193                                         snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3194                                 }
3195                         }
3196
3197                         if (g_file_test (buf, G_FILE_TEST_EXISTS)) {
3198                                 existing++;
3199                         }
3200
3201                 }
3202
3203                 if (existing == 0) {
3204                         break;
3205                 }
3206
3207                 if (cnt > limit) {
3208                         error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
3209                         destroy ();
3210                         throw failed_constructor();
3211                 }
3212         }
3213
3214         /* we now have a unique name for the file, but figure out where to
3215            actually put it.
3216         */
3217
3218         string foo = buf;
3219
3220         spath = discover_best_sound_dir ();
3221         spath += '/';
3222
3223         string::size_type pos = foo.find_last_of ('/');
3224
3225         if (pos == string::npos) {
3226                 spath += foo;
3227         } else {
3228                 spath += foo.substr (pos + 1);
3229         }
3230
3231         return spath;
3232 }
3233
3234 boost::shared_ptr<AudioFileSource>
3235 Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
3236 {
3237         string spath = audio_path_from_name (ds.name(), ds.n_channels(), chan, destructive);
3238         return boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, spath, destructive, frame_rate()));
3239 }
3240
3241 /* Playlist management */
3242
3243 boost::shared_ptr<Playlist>
3244 Session::playlist_by_name (string name)
3245 {
3246         Glib::Mutex::Lock lm (playlist_lock);
3247         for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3248                 if ((*i)->name() == name) {
3249                         return* i;
3250                 }
3251         }
3252         for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3253                 if ((*i)->name() == name) {
3254                         return* i;
3255                 }
3256         }
3257
3258         return boost::shared_ptr<Playlist>();
3259 }
3260
3261 void
3262 Session::add_playlist (boost::shared_ptr<Playlist> playlist)
3263 {
3264         if (playlist->hidden()) {
3265                 return;
3266         }
3267
3268         {
3269                 Glib::Mutex::Lock lm (playlist_lock);
3270                 if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
3271                         playlists.insert (playlists.begin(), playlist);
3272                         playlist->InUse.connect (sigc::bind (mem_fun (*this, &Session::track_playlist), boost::weak_ptr<Playlist>(playlist)));
3273                         playlist->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
3274                 }
3275         }
3276
3277         set_dirty();
3278
3279         PlaylistAdded (playlist); /* EMIT SIGNAL */
3280 }
3281
3282 void
3283 Session::get_playlists (vector<boost::shared_ptr<Playlist> >& s)
3284 {
3285         {
3286                 Glib::Mutex::Lock lm (playlist_lock);
3287                 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3288                         s.push_back (*i);
3289                 }
3290                 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3291                         s.push_back (*i);
3292                 }
3293         }
3294 }
3295
3296 void
3297 Session::track_playlist (bool inuse, boost::weak_ptr<Playlist> wpl)
3298 {
3299         boost::shared_ptr<Playlist> pl(wpl.lock());
3300
3301         if (!pl) {
3302                 return;
3303         }
3304
3305         PlaylistList::iterator x;
3306
3307         if (pl->hidden()) {
3308                 /* its not supposed to be visible */
3309                 return;
3310         }
3311
3312         {
3313                 Glib::Mutex::Lock lm (playlist_lock);
3314
3315                 if (!inuse) {
3316
3317                         unused_playlists.insert (pl);
3318
3319                         if ((x = playlists.find (pl)) != playlists.end()) {
3320                                 playlists.erase (x);
3321                         }
3322
3323
3324                 } else {
3325
3326                         playlists.insert (pl);
3327
3328                         if ((x = unused_playlists.find (pl)) != unused_playlists.end()) {
3329                                 unused_playlists.erase (x);
3330                         }
3331                 }
3332         }
3333 }
3334
3335 void
3336 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3337 {
3338         if (_state_of_the_state & Deletion) {
3339                 return;
3340         }
3341
3342         boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3343
3344         if (!playlist) {
3345                 return;
3346         }
3347
3348         {
3349                 Glib::Mutex::Lock lm (playlist_lock);
3350
3351                 PlaylistList::iterator i;
3352
3353                 i = find (playlists.begin(), playlists.end(), playlist);
3354                 if (i != playlists.end()) {
3355                         playlists.erase (i);
3356                 }
3357
3358                 i = find (unused_playlists.begin(), unused_playlists.end(), playlist);
3359                 if (i != unused_playlists.end()) {
3360                         unused_playlists.erase (i);
3361                 }
3362
3363         }
3364
3365         set_dirty();
3366
3367         PlaylistRemoved (playlist); /* EMIT SIGNAL */
3368 }
3369
3370 void
3371 Session::set_audition (boost::shared_ptr<Region> r)
3372 {
3373         pending_audition_region = r;
3374         post_transport_work = PostTransportWork (post_transport_work | PostTransportAudition);
3375         schedule_butler_transport_work ();
3376 }
3377
3378 void
3379 Session::audition_playlist ()
3380 {
3381         Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3382         ev->region.reset ();
3383         queue_event (ev);
3384 }
3385
3386 void
3387 Session::non_realtime_set_audition ()
3388 {
3389         if (!pending_audition_region) {
3390                 auditioner->audition_current_playlist ();
3391         } else {
3392                 auditioner->audition_region (pending_audition_region);
3393                 pending_audition_region.reset ();
3394         }
3395         AuditionActive (true); /* EMIT SIGNAL */
3396 }
3397
3398 void
3399 Session::audition_region (boost::shared_ptr<Region> r)
3400 {
3401         Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3402         ev->region = r;
3403         queue_event (ev);
3404 }
3405
3406 void
3407 Session::cancel_audition ()
3408 {
3409         if (auditioner->active()) {
3410                 auditioner->cancel_audition ();
3411                 AuditionActive (false); /* EMIT SIGNAL */
3412         }
3413 }
3414
3415 bool
3416 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3417 {
3418         return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3419 }
3420
3421 void
3422 Session::remove_empty_sounds ()
3423 {
3424         PathScanner scanner;
3425
3426         vector<string *>* possible_audiofiles = scanner (sound_dir(), "\\.(wav|aiff|caf|w64|L|R)$", false, true);
3427
3428         Glib::Mutex::Lock lm (audio_source_lock);
3429
3430         regex_t compiled_tape_track_pattern;
3431         int err;
3432
3433         if ((err = regcomp (&compiled_tape_track_pattern, "/T[0-9][0-9][0-9][0-9]-", REG_EXTENDED|REG_NOSUB))) {
3434
3435                 char msg[256];
3436
3437                 regerror (err, &compiled_tape_track_pattern, msg, sizeof (msg));
3438
3439                 error << string_compose (_("Cannot compile tape track regexp for use (%1)"), msg) << endmsg;
3440                 return;
3441         }
3442
3443         for (vector<string *>::iterator i = possible_audiofiles->begin(); i != possible_audiofiles->end(); ++i) {
3444
3445                 /* never remove files that appear to be a tape track */
3446
3447                 if (regexec (&compiled_tape_track_pattern, (*i)->c_str(), 0, 0, 0) == 0) {
3448                         delete *i;
3449                         continue;
3450                 }
3451
3452                 if (AudioFileSource::is_empty (*this, **i)) {
3453
3454                         unlink ((*i)->c_str());
3455
3456                         Glib::ustring peakpath = peak_path (PBD::basename_nosuffix (**i));
3457                         unlink (peakpath.c_str());
3458                 }
3459
3460                 delete* i;
3461         }
3462
3463         delete possible_audiofiles;
3464 }
3465
3466 bool
3467 Session::is_auditioning () const
3468 {
3469         /* can be called before we have an auditioner object */
3470         if (auditioner) {
3471                 return auditioner->active();
3472         } else {
3473                 return false;
3474         }
3475 }
3476
3477 void
3478 Session::set_all_solo (bool yn)
3479 {
3480         shared_ptr<RouteList> r = routes.reader ();
3481
3482         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3483                 if (!(*i)->hidden()) {
3484                         (*i)->set_solo (yn, this);
3485                 }
3486         }
3487
3488         set_dirty();
3489 }
3490
3491 void
3492 Session::set_all_mute (bool yn)
3493 {
3494         shared_ptr<RouteList> r = routes.reader ();
3495
3496         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3497                 if (!(*i)->hidden()) {
3498                         (*i)->set_mute (yn, this);
3499                 }
3500         }
3501
3502         set_dirty();
3503 }
3504
3505 uint32_t
3506 Session::n_diskstreams () const
3507 {
3508         uint32_t n = 0;
3509
3510         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3511
3512         for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
3513                 if (!(*i)->hidden()) {
3514                         n++;
3515                 }
3516         }
3517         return n;
3518 }
3519
3520 void
3521 Session::graph_reordered ()
3522 {
3523         /* don't do this stuff if we are setting up connections
3524            from a set_state() call or creating new tracks.
3525         */
3526
3527         if (_state_of_the_state & InitialConnecting) {
3528                 return;
3529         }
3530
3531         /* every track/bus asked for this to be handled but it was deferred because
3532            we were connecting. do it now.
3533         */
3534
3535         request_input_change_handling ();
3536
3537         resort_routes ();
3538
3539         /* force all diskstreams to update their capture offset values to
3540            reflect any changes in latencies within the graph.
3541         */
3542
3543         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3544
3545         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3546                 (*i)->set_capture_offset ();
3547         }
3548 }
3549
3550 void
3551 Session::record_disenable_all ()
3552 {
3553         record_enable_change_all (false);
3554 }
3555
3556 void
3557 Session::record_enable_all ()
3558 {
3559         record_enable_change_all (true);
3560 }
3561
3562 void
3563 Session::record_enable_change_all (bool yn)
3564 {
3565         shared_ptr<RouteList> r = routes.reader ();
3566
3567         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3568                 AudioTrack* at;
3569
3570                 if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
3571                         at->set_record_enable (yn, this);
3572                 }
3573         }
3574
3575         /* since we don't keep rec-enable state, don't mark session dirty */
3576 }
3577
3578 void
3579 Session::add_redirect (Redirect* redirect)
3580 {
3581         Send* send;
3582         Insert* insert;
3583         PortInsert* port_insert;
3584         PluginInsert* plugin_insert;
3585
3586         if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3587                 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3588                         _port_inserts.insert (_port_inserts.begin(), port_insert);
3589                 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3590                         _plugin_inserts.insert (_plugin_inserts.begin(), plugin_insert);
3591                 } else {
3592                         fatal << _("programming error: unknown type of Insert created!") << endmsg;
3593                         /*NOTREACHED*/
3594                 }
3595         } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3596                 _sends.insert (_sends.begin(), send);
3597         } else {
3598                 fatal << _("programming error: unknown type of Redirect created!") << endmsg;
3599                 /*NOTREACHED*/
3600         }
3601
3602         redirect->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_redirect), redirect));
3603
3604         set_dirty();
3605 }
3606
3607 void
3608 Session::remove_redirect (Redirect* redirect)
3609 {
3610         Send* send;
3611         Insert* insert;
3612         PortInsert* port_insert;
3613         PluginInsert* plugin_insert;
3614
3615         if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3616                 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3617                         list<PortInsert*>::iterator x = find (_port_inserts.begin(), _port_inserts.end(), port_insert);
3618                         if (x != _port_inserts.end()) {
3619                                 insert_bitset[port_insert->bit_slot()] = false;
3620                                 _port_inserts.erase (x);
3621                         }
3622                 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3623                         _plugin_inserts.remove (plugin_insert);
3624                 } else {
3625                         fatal << string_compose (_("programming error: %1"),
3626                                                  X_("unknown type of Insert deleted!"))
3627                               << endmsg;
3628                         /*NOTREACHED*/
3629                 }
3630         } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3631                 list<Send*>::iterator x = find (_sends.begin(), _sends.end(), send);
3632                 if (x != _sends.end()) {
3633                         send_bitset[send->bit_slot()] = false;
3634                         _sends.erase (x);
3635                 }
3636         } else {
3637                 fatal << _("programming error: unknown type of Redirect deleted!") << endmsg;
3638                 /*NOTREACHED*/
3639         }
3640
3641         set_dirty();
3642 }
3643
3644 nframes_t
3645 Session::available_capture_duration ()
3646 {
3647         float sample_bytes_on_disk = 4.0; // keep gcc happy
3648
3649         switch (Config->get_native_file_data_format()) {
3650         case FormatFloat:
3651                 sample_bytes_on_disk = 4.0;
3652                 break;
3653
3654         case FormatInt24:
3655                 sample_bytes_on_disk = 3.0;
3656                 break;
3657
3658         case FormatInt16:
3659                 sample_bytes_on_disk = 2.0;
3660                 break;
3661
3662         default:
3663                 /* impossible, but keep some gcc versions happy */
3664                 fatal << string_compose (_("programming error: %1"),
3665                                          X_("illegal native file data format"))
3666                       << endmsg;
3667                 /*NOTREACHED*/
3668         }
3669
3670         double scale = 4096.0 / sample_bytes_on_disk;
3671
3672         if (_total_free_4k_blocks * scale > (double) max_frames) {
3673                 return max_frames;
3674         }
3675
3676         return (nframes_t) floor (_total_free_4k_blocks * scale);
3677 }
3678
3679 void
3680 Session::add_connection (ARDOUR::Connection* connection)
3681 {
3682         {
3683                 Glib::Mutex::Lock guard (connection_lock);
3684                 _connections.push_back (connection);
3685         }
3686
3687         ConnectionAdded (connection); /* EMIT SIGNAL */
3688
3689         set_dirty();
3690 }
3691
3692 void
3693 Session::remove_connection (ARDOUR::Connection* connection)
3694 {
3695         bool removed = false;
3696
3697         {
3698                 Glib::Mutex::Lock guard (connection_lock);
3699                 ConnectionList::iterator i = find (_connections.begin(), _connections.end(), connection);
3700
3701                 if (i != _connections.end()) {
3702                         _connections.erase (i);
3703                         removed = true;
3704                 }
3705         }
3706
3707         if (removed) {
3708                  ConnectionRemoved (connection); /* EMIT SIGNAL */
3709         }
3710
3711         set_dirty();
3712 }
3713
3714 ARDOUR::Connection *
3715 Session::connection_by_name (string name) const
3716 {
3717         Glib::Mutex::Lock lm (connection_lock);
3718
3719         for (ConnectionList::const_iterator i = _connections.begin(); i != _connections.end(); ++i) {
3720                 if ((*i)->name() == name) {
3721                         return* i;
3722                 }
3723         }
3724
3725         return 0;
3726 }
3727
3728 void
3729 Session::tempo_map_changed (Change ignored)
3730 {
3731         clear_clicks ();
3732
3733         for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3734                 (*i)->update_after_tempo_map_change ();
3735         }
3736
3737         for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3738                 (*i)->update_after_tempo_map_change ();
3739         }
3740
3741         set_dirty ();
3742 }
3743
3744 void
3745 Session::ensure_passthru_buffers (uint32_t howmany)
3746 {
3747         if (current_block_size == 0) {
3748                 return;
3749         }
3750
3751         while (howmany > _passthru_buffers.size()) {
3752                 Sample *p;
3753 #ifdef NO_POSIX_MEMALIGN
3754                 p =  (Sample *) malloc(current_block_size * sizeof(Sample));
3755 #else
3756                 if (posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample)) != 0) {
3757                         fatal << string_compose (_("Memory allocation error: posix_memalign (%1 * %2) failed (%3)"),
3758                                                  current_block_size, sizeof (Sample), strerror (errno))
3759                               << endmsg;
3760                         /*NOTREACHED*/
3761                 }
3762 #endif
3763                 _passthru_buffers.push_back (p);
3764
3765                 *p = 0;
3766
3767 #ifdef NO_POSIX_MEMALIGN
3768                 p =  (Sample *) malloc(current_block_size * sizeof(Sample));
3769 #else
3770                 if (posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample)) != 0) {
3771                         fatal << string_compose (_("Memory allocation error: posix_memalign (%1 * %2) failed (%3)"),
3772                                                  current_block_size, sizeof (Sample), strerror (errno))
3773                               << endmsg;
3774                         /*NOTREACHED*/
3775                 }
3776 #endif
3777                 memset (p, 0, sizeof (Sample) * current_block_size);
3778                 _silent_buffers.push_back (p);
3779
3780                 *p = 0;
3781
3782 #ifdef NO_POSIX_MEMALIGN
3783                 p =  (Sample *) malloc(current_block_size * sizeof(Sample));
3784 #else
3785                 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
3786 #endif
3787                 memset (p, 0, sizeof (Sample) * current_block_size);
3788                 _send_buffers.push_back (p);
3789
3790         }
3791         allocate_pan_automation_buffers (current_block_size, howmany, false);
3792 }
3793
3794 uint32_t
3795 Session::next_insert_id ()
3796 {
3797         /* this doesn't really loop forever. just think about it */
3798
3799         while (true) {
3800                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3801                         if (!insert_bitset[n]) {
3802                                 insert_bitset[n] = true;
3803                                 return n;
3804
3805                         }
3806                 }
3807
3808                 /* none available, so resize and try again */
3809
3810                 insert_bitset.resize (insert_bitset.size() + 16, false);
3811         }
3812 }
3813
3814 uint32_t
3815 Session::next_send_id ()
3816 {
3817         /* this doesn't really loop forever. just think about it */
3818
3819         while (true) {
3820                 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3821                         if (!send_bitset[n]) {
3822                                 send_bitset[n] = true;
3823                                 return n;
3824
3825                         }
3826                 }
3827
3828                 /* none available, so resize and try again */
3829
3830                 send_bitset.resize (send_bitset.size() + 16, false);
3831         }
3832 }
3833
3834 void
3835 Session::mark_send_id (uint32_t id)
3836 {
3837         if (id >= send_bitset.size()) {
3838                 send_bitset.resize (id+16, false);
3839         }
3840         if (send_bitset[id]) {
3841                 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3842         }
3843         send_bitset[id] = true;
3844 }
3845
3846 void
3847 Session::mark_insert_id (uint32_t id)
3848 {
3849         if (id >= insert_bitset.size()) {
3850                 insert_bitset.resize (id+16, false);
3851         }
3852         if (insert_bitset[id]) {
3853                 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3854         }
3855         insert_bitset[id] = true;
3856 }
3857
3858 /* Named Selection management */
3859
3860 NamedSelection *
3861 Session::named_selection_by_name (string name)
3862 {
3863         Glib::Mutex::Lock lm (named_selection_lock);
3864         for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3865                 if ((*i)->name == name) {
3866                         return* i;
3867                 }
3868         }
3869         return 0;
3870 }
3871
3872 void
3873 Session::add_named_selection (NamedSelection* named_selection)
3874 {
3875         {
3876                 Glib::Mutex::Lock lm (named_selection_lock);
3877                 named_selections.insert (named_selections.begin(), named_selection);
3878         }
3879
3880         for (list<boost::shared_ptr<Playlist> >::iterator i = named_selection->playlists.begin(); i != named_selection->playlists.end(); ++i) {
3881                 add_playlist (*i);
3882         }
3883
3884         set_dirty();
3885
3886         NamedSelectionAdded (); /* EMIT SIGNAL */
3887 }
3888
3889 void
3890 Session::remove_named_selection (NamedSelection* named_selection)
3891 {
3892         bool removed = false;
3893
3894         {
3895                 Glib::Mutex::Lock lm (named_selection_lock);
3896
3897                 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3898
3899                 if (i != named_selections.end()) {
3900                         delete (*i);
3901                         named_selections.erase (i);
3902                         set_dirty();
3903                         removed = true;
3904                 }
3905         }
3906
3907         if (removed) {
3908                  NamedSelectionRemoved (); /* EMIT SIGNAL */
3909         }
3910 }
3911
3912 void
3913 Session::reset_native_file_format ()
3914 {
3915         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3916
3917         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3918                 (*i)->reset_write_sources (false);
3919         }
3920 }
3921
3922 bool
3923 Session::route_name_unique (string n) const
3924 {
3925         shared_ptr<RouteList> r = routes.reader ();
3926
3927         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3928                 if ((*i)->name() == n) {
3929                         return false;
3930                 }
3931         }
3932
3933         return true;
3934 }
3935
3936 uint32_t
3937 Session::n_playlists () const
3938 {
3939         Glib::Mutex::Lock lm (playlist_lock);
3940         return playlists.size();
3941 }
3942
3943 void
3944 Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
3945 {
3946         if (!force && howmany <= _npan_buffers) {
3947                 return;
3948         }
3949
3950         if (_pan_automation_buffer) {
3951
3952                 for (uint32_t i = 0; i < _npan_buffers; ++i) {
3953                         delete [] _pan_automation_buffer[i];
3954                 }
3955
3956                 delete [] _pan_automation_buffer;
3957         }
3958
3959         _pan_automation_buffer = new pan_t*[howmany];
3960
3961         for (uint32_t i = 0; i < howmany; ++i) {
3962                 _pan_automation_buffer[i] = new pan_t[nframes];
3963         }
3964
3965         _npan_buffers = howmany;
3966 }
3967
3968 int
3969 Session::freeze (InterThreadInfo& itt)
3970 {
3971         shared_ptr<RouteList> r = routes.reader ();
3972
3973         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3974
3975                 AudioTrack *at;
3976
3977                 if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
3978                         /* XXX this is wrong because itt.progress will keep returning to zero at the start
3979                            of every track.
3980                         */
3981                         at->freeze (itt);
3982                 }
3983         }
3984
3985         return 0;
3986 }
3987
3988 boost::shared_ptr<Region>
3989 Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t end,
3990                                bool overwrite, vector<boost::shared_ptr<AudioSource> >& srcs, InterThreadInfo& itt)
3991 {
3992         boost::shared_ptr<Region> result;
3993         boost::shared_ptr<Playlist> playlist;
3994         boost::shared_ptr<AudioFileSource> fsource;
3995         uint32_t x;
3996         char buf[PATH_MAX+1];
3997         string dir;
3998         uint32_t nchans;
3999         nframes_t position;
4000         nframes_t this_chunk;
4001         nframes_t to_do;
4002         nframes_t len = end - start;
4003         vector<Sample*> buffers;
4004
4005         if (end <= start) {
4006                 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
4007                                          end, start) << endmsg;
4008                 return result;
4009         }
4010
4011         // any bigger than this seems to cause stack overflows in called functions
4012         const nframes_t chunk_size = (128 * 1024)/4;
4013
4014         g_atomic_int_set (&processing_prohibited, 1);
4015
4016         /* call tree *MUST* hold route_lock */
4017
4018         if ((playlist = track.diskstream()->playlist()) == 0) {
4019                 goto out;
4020         }
4021
4022         /* external redirects will be a problem */
4023
4024         if (track.has_external_redirects()) {
4025                 goto out;
4026         }
4027
4028         nchans = track.audio_diskstream()->n_channels();
4029
4030         dir = discover_best_sound_dir ();
4031
4032         for (uint32_t chan_n=0; chan_n < nchans; ++chan_n) {
4033
4034                 for (x = 0; x < 99999; ++x) {
4035                         snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", dir.c_str(), playlist->name().c_str(), chan_n, x+1);
4036                         if (access (buf, F_OK) != 0) {
4037                                 break;
4038                         }
4039                 }
4040
4041                 if (x == 99999) {
4042                         error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4043                         goto out;
4044                 }
4045
4046                 try {
4047                         fsource = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, buf, false, frame_rate()));
4048                 }
4049
4050                 catch (failed_constructor& err) {
4051                         error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4052                         goto out;
4053                 }
4054
4055                 srcs.push_back (fsource);
4056         }
4057
4058         /* XXX need to flush all redirects */
4059
4060         position = start;
4061         to_do = len;
4062
4063         /* create a set of reasonably-sized buffers */
4064
4065         for (vector<Sample*>::iterator i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i) {
4066                 Sample* b;
4067 #ifdef NO_POSIX_MEMALIGN
4068                 b =  (Sample *) malloc(chunk_size * sizeof(Sample));
4069 #else
4070                 posix_memalign((void **)&b,4096,chunk_size * sizeof(Sample));
4071 #endif
4072                 buffers.push_back (b);
4073         }
4074
4075         for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4076                 (*src)->prepare_for_peakfile_writes ();
4077         }
4078
4079         while (to_do && !itt.cancel) {
4080
4081                 this_chunk = min (to_do, chunk_size);
4082
4083                 if (track.export_stuff (buffers, nchans, start, this_chunk)) {
4084                         goto out;
4085                 }
4086
4087                 uint32_t n = 0;
4088                 for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4089                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4090
4091                         if (afs) {
4092                                 if (afs->write (buffers[n], this_chunk) != this_chunk) {
4093                                         goto out;
4094                                 }
4095                         }
4096                 }
4097
4098                 start += this_chunk;
4099                 to_do -= this_chunk;
4100
4101                 itt.progress = (float) (1.0 - ((double) to_do / len));
4102
4103         }
4104
4105         if (!itt.cancel) {
4106
4107                 time_t now;
4108                 struct tm* xnow;
4109                 time (&now);
4110                 xnow = localtime (&now);
4111
4112                 for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4113                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4114
4115                         if (afs) {
4116                                 afs->update_header (position, *xnow, now);
4117                                 afs->flush_header ();
4118                         }
4119                 }
4120
4121                 /* construct a region to represent the bounced material */
4122
4123                 result = RegionFactory::create (srcs, 0, srcs.front()->length(),
4124                                                 region_name_from_path (srcs.front()->name(), true));
4125         }
4126
4127   out:
4128         if (!result) {
4129                 for (vector<boost::shared_ptr<AudioSource> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4130                         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4131
4132                         if (afs) {
4133                                 afs->mark_for_remove ();
4134                         }
4135
4136                         (*src)->drop_references ();
4137                 }
4138
4139         } else {
4140                 for (vector<boost::shared_ptr<AudioSource> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4141                         (*src)->done_with_peakfile_writes ();
4142                 }
4143         }
4144
4145         for (vector<Sample*>::iterator i = buffers.begin(); i != buffers.end(); ++i) {
4146                 free (*i);
4147         }
4148
4149         g_atomic_int_set (&processing_prohibited, 0);
4150
4151         itt.done = true;
4152
4153         return result;
4154 }
4155
4156 vector<Sample*>&
4157 Session::get_silent_buffers (uint32_t howmany)
4158 {
4159         if (howmany > _silent_buffers.size()) {
4160
4161                 error << string_compose (_("Programming error: get_silent_buffers() called for %1 buffers but only %2 exist"),
4162                                          howmany, _silent_buffers.size()) << endmsg;
4163
4164                 if (howmany > 1000) {
4165                         cerr << "ABSURD: more than 1000 silent buffers requested!\n";
4166                         abort ();
4167                 }
4168
4169                 while (howmany > _silent_buffers.size()) {
4170                         Sample *p = 0;
4171
4172 #ifdef NO_POSIX_MEMALIGN
4173                         p =  (Sample *) malloc(current_block_size * sizeof(Sample));
4174 #else
4175                         if (posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample)) != 0) {
4176                                 fatal << string_compose (_("Memory allocation error: posix_memalign (%1 * %2) failed (%3)"),
4177                                                          current_block_size, sizeof (Sample), strerror (errno))
4178                                       << endmsg;
4179                                 /*NOTREACHED*/
4180                         }
4181 #endif
4182                         _silent_buffers.push_back (p);
4183                 }
4184         }
4185
4186         for (uint32_t i = 0; i < howmany; ++i) {
4187                 memset (_silent_buffers[i], 0, sizeof (Sample) * current_block_size);
4188         }
4189
4190         return _silent_buffers;
4191 }
4192
4193 uint32_t
4194 Session::ntracks () const
4195 {
4196         uint32_t n = 0;
4197         shared_ptr<RouteList> r = routes.reader ();
4198
4199         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4200                 if (dynamic_cast<AudioTrack*> ((*i).get())) {
4201                         ++n;
4202                 }
4203         }
4204
4205         return n;
4206 }
4207
4208 uint32_t
4209 Session::nbusses () const
4210 {
4211         uint32_t n = 0;
4212         shared_ptr<RouteList> r = routes.reader ();
4213
4214         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4215                 if (dynamic_cast<AudioTrack*> ((*i).get()) == 0) {
4216                         ++n;
4217                 }
4218         }
4219
4220         return n;
4221 }
4222
4223 void
4224 Session::add_automation_list(AutomationList *al)
4225 {
4226         automation_lists[al->id()] = al;
4227 }
4228
4229 nframes_t
4230 Session::compute_initial_length ()
4231 {
4232         return _engine.frame_rate() * 60 * 5;
4233 }
4234
4235 void
4236 Session::sync_order_keys (const char* base)
4237 {
4238         if (!Config->get_sync_all_route_ordering()) {
4239                 /* leave order keys as they are */
4240                 return;
4241         }
4242
4243         boost::shared_ptr<RouteList> r = routes.reader ();
4244
4245         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4246                 (*i)->sync_order_keys (base);
4247         }
4248
4249         Route::SyncOrderKeys (base); // EMIT SIGNAL
4250 }