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