libs/ardour/session.cc

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