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