libs/ardour/audioengine.cc

   1 /*
   2     Copyright (C) 2002 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 <unistd.h>
  21 #include <cerrno>
  22 #include <vector>
  23 #include <exception>
  24 #include <stdexcept>
  25 #include <sstream>
  26
  27 #include <glibmm/timer.h>
  28
  29 #include "pbd/pthread_utils.h"
  30 #include "pbd/stacktrace.h"
  31 #include "pbd/unknown_type.h"
  32 #include "pbd/epa.h"
  33
  34 #include <jack/weakjack.h>
  35
  36 #include "midi++/port.h"
  37 #include "midi++/mmc.h"
  38 #include "midi++/manager.h"
  39
  40 #include "ardour/amp.h"
  41 #include "ardour/audio_port.h"
  42 #include "ardour/audioengine.h"
  43 #include "ardour/buffer.h"
  44 #include "ardour/buffer_set.h"
  45 #include "ardour/cycle_timer.h"
  46 #include "ardour/event_type_map.h"
  47 #include "ardour/internal_return.h"
  48 #include "ardour/internal_send.h"
  49 #include "ardour/io.h"
  50 #include "ardour/meter.h"
  51 #include "ardour/midi_port.h"
  52 #include "ardour/process_thread.h"
  53 #include "ardour/port.h"
  54 #include "ardour/port_set.h"
  55 #include "ardour/session.h"
  56 #include "ardour/timestamps.h"
  57 #include "ardour/utils.h"
  58
  59 #include "i18n.h"
  60
  61 using namespace std;
  62 using namespace ARDOUR;
  63 using namespace PBD;
  64
  65 gint AudioEngine::m_meter_exit;
  66 AudioEngine* AudioEngine::_instance = 0;
  67
  68 #define GET_PRIVATE_JACK_POINTER(j)  jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
  69 #define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
  70
  71 AudioEngine::AudioEngine (string client_name, string session_uuid)
  72         : ports (new Ports)
  73 {
  74         _instance = this; /* singleton */
  75
  76         session_remove_pending = false;
  77         _running = false;
  78         _has_run = false;
  79         last_monitor_check = 0;
  80         monitor_check_interval = INT32_MAX;
  81         _processed_frames = 0;
  82         _usecs_per_cycle = 0;
  83         _jack = 0;
  84         _frame_rate = 0;
  85         _buffer_size = 0;
  86         _freewheeling = false;
  87         _main_thread = 0;
  88         port_remove_in_progress = false;
  89
  90         m_meter_thread = 0;
  91         g_atomic_int_set (&m_meter_exit, 0);
  92
  93         if (connect_to_jack (client_name, session_uuid)) {
  94                 throw NoBackendAvailable ();
  95         }
  96
  97         Port::set_engine (this);
  98 }
  99
 100 AudioEngine::~AudioEngine ()
 101 {
 102         {
 103                 Glib::Mutex::Lock tm (_process_lock);
 104                 session_removed.signal ();
 105
 106                 if (_running) {
 107                         jack_client_close (_jack);
 108                         _jack = 0;
 109                 }
 110
 111                 stop_metering_thread ();
 112         }
 113 }
 114
 115 jack_client_t*
 116 AudioEngine::jack() const
 117 {
 118         return _jack;
 119 }
 120
 121 void
 122 _thread_init_callback (void * /*arg*/)
 123 {
 124         /* make sure that anybody who needs to know about this thread
 125            knows about it.
 126         */
 127
 128         pthread_set_name (X_("audioengine"));
 129
 130         PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
 131         PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
 132
 133         SessionEvent::create_per_thread_pool (X_("Audioengine"), 512);
 134
 135         MIDI::Port::set_process_thread (pthread_self());
 136 }
 137
 138 static void
 139 ardour_jack_error (const char* msg)
 140 {
 141         error << "JACK: " << msg << endmsg;
 142 }
 143
 144 void
 145 AudioEngine::set_jack_callbacks ()
 146 {
 147         GET_PRIVATE_JACK_POINTER (_jack);
 148
 149         if (jack_on_info_shutdown) {
 150                 jack_on_info_shutdown (_priv_jack, halted_info, this);
 151         } else {
 152                 jack_on_shutdown (_priv_jack, halted, this);
 153         }
 154
 155         jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
 156         jack_set_process_thread (_priv_jack, _process_thread, this);
 157         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 158         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 159         jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
 160         jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
 161         jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
 162         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 163         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 164         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 165
 166         if (_session && _session->config.get_jack_time_master()) {
 167                 jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 168         }
 169
 170 #ifdef HAVE_JACK_SESSION
 171         if( jack_set_session_callback)
 172                 jack_set_session_callback (_priv_jack, _session_callback, this);
 173 #endif
 174
 175         if (jack_set_latency_callback) {
 176                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 177         }
 178
 179         jack_set_error_function (ardour_jack_error);
 180 }
 181
 182 int
 183 AudioEngine::start ()
 184 {
 185         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 186
 187         if (!_running) {
 188
 189                 if (!jack_port_type_get_buffer_size) {
 190                         warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
 191                 }
 192
 193                 if (_session) {
 194                         BootMessage (_("Connect session to engine"));
 195                         _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
 196                 }
 197
 198                 /* a proxy for whether jack_activate() will definitely call the buffer size
 199                  * callback. with older versions of JACK, this function symbol will be null.
 200                  * this is reliable, but not clean.
 201                  */
 202
 203                 if (!jack_port_type_get_buffer_size) {
 204                         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 205                 }
 206
 207                 _processed_frames = 0;
 208                 last_monitor_check = 0;
 209
 210                 set_jack_callbacks ();
 211
 212                 if (jack_activate (_priv_jack) == 0) {
 213                         _running = true;
 214                         _has_run = true;
 215                         Running(); /* EMIT SIGNAL */
 216                 } else {
 217                         // error << _("cannot activate JACK client") << endmsg;
 218                 }
 219         }
 220
 221         return _running ? 0 : -1;
 222 }
 223
 224 int
 225 AudioEngine::stop (bool forever)
 226 {
 227         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 228
 229         if (_priv_jack) {
 230                 if (forever) {
 231                         disconnect_from_jack ();
 232                 } else {
 233                         jack_deactivate (_priv_jack);
 234                         Stopped(); /* EMIT SIGNAL */
 235                         MIDI::Port::JackHalted (); /* EMIT SIGNAL */
 236                 }
 237         }
 238
 239         if (forever) {
 240                 stop_metering_thread ();
 241         }
 242
 243         return _running ? -1 : 0;
 244 }
 245
 246
 247 bool
 248 AudioEngine::get_sync_offset (pframes_t& offset) const
 249 {
 250
 251 #ifdef HAVE_JACK_VIDEO_SUPPORT
 252
 253         GET_PRIVATE_JACK_POINTER_RET (_jack, false);
 254
 255         jack_position_t pos;
 256
 257         if (_priv_jack) {
 258                 (void) jack_transport_query (_priv_jack, &pos);
 259
 260                 if (pos.valid & JackVideoFrameOffset) {
 261                         offset = pos.video_offset;
 262                         return true;
 263                 }
 264         }
 265 #else
 266         /* keep gcc happy */
 267         offset = 0;
 268 #endif
 269
 270         return false;
 271 }
 272
 273 void
 274 AudioEngine::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 275                                       jack_position_t* pos, int new_position, void *arg)
 276 {
 277         static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 278 }
 279
 280 void
 281 AudioEngine::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 282                                      jack_position_t* pos, int new_position)
 283 {
 284         if (_jack && _session && _session->synced_to_jack()) {
 285                 _session->jack_timebase_callback (state, nframes, pos, new_position);
 286         }
 287 }
 288
 289 int
 290 AudioEngine::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 291 {
 292         return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
 293 }
 294
 295 int
 296 AudioEngine::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 297 {
 298         if (_jack && _session) {
 299                 return _session->jack_sync_callback (state, pos);
 300         }
 301
 302         return true;
 303 }
 304
 305 int
 306 AudioEngine::_xrun_callback (void *arg)
 307 {
 308         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 309         if (ae->connected()) {
 310                 ae->Xrun (); /* EMIT SIGNAL */
 311         }
 312         return 0;
 313 }
 314
 315 #ifdef HAVE_JACK_SESSION
 316 void
 317 AudioEngine::_session_callback (jack_session_event_t *event, void *arg)
 318 {
 319         printf( "helo.... " );
 320         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 321         if (ae->connected()) {
 322                 ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
 323         }
 324 }
 325 #endif
 326 int
 327 AudioEngine::_graph_order_callback (void *arg)
 328 {
 329         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 330
 331         if (ae->connected() && !ae->port_remove_in_progress) {
 332                 ae->GraphReordered (); /* EMIT SIGNAL */
 333         }
 334
 335         return 0;
 336 }
 337
 338 void*
 339 AudioEngine::_process_thread (void *arg)
 340 {
 341         return static_cast<AudioEngine *> (arg)->process_thread ();
 342 }
 343
 344 void
 345 AudioEngine::_freewheel_callback (int onoff, void *arg)
 346 {
 347         static_cast<AudioEngine*>(arg)->_freewheeling = onoff;
 348 }
 349
 350 void
 351 AudioEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
 352 {
 353         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 354
 355         if (!ae->port_remove_in_progress) {
 356                 ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
 357         }
 358 }
 359
 360 void
 361 AudioEngine::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 362 {
 363         return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
 364 }
 365
 366 void
 367 AudioEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
 368 {
 369         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 370
 371         if (ae->port_remove_in_progress) {
 372                 return;
 373         }
 374
 375         GET_PRIVATE_JACK_POINTER (ae->_jack);
 376
 377         jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
 378         jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
 379
 380         boost::shared_ptr<Port> port_a;
 381         boost::shared_ptr<Port> port_b;
 382
 383         boost::shared_ptr<Ports> pr = ae->ports.reader ();
 384         Ports::iterator i = pr->begin ();
 385         while (i != pr->end() && (port_a == 0 || port_b == 0)) {
 386                 if (jack_port_a == i->second->jack_port()) {
 387                         port_a = i->second;
 388                 } else if (jack_port_b == i->second->jack_port()) {
 389                         port_b = i->second;
 390                 }
 391                 ++i;
 392         }
 393
 394         ae->PortConnectedOrDisconnected (
 395                 port_a, jack_port_name (jack_port_a),
 396                 port_b, jack_port_name (jack_port_b),
 397                 conn == 0 ? false : true
 398                 ); /* EMIT SIGNAL */
 399 }
 400
 401 void
 402 AudioEngine::split_cycle (pframes_t offset)
 403 {
 404         /* caller must hold process lock */
 405
 406         Port::increment_global_port_buffer_offset (offset);
 407
 408         /* tell all Ports that we're going to start a new (split) cycle */
 409
 410         boost::shared_ptr<Ports> p = ports.reader();
 411
 412         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 413                 i->second->cycle_split ();
 414         }
 415 }
 416
 417 void*
 418 AudioEngine::process_thread ()
 419 {
 420         /* JACK doesn't do this for us when we use the wait API
 421          */
 422
 423         _thread_init_callback (0);
 424
 425         _main_thread = new ProcessThread;
 426
 427         while (1) {
 428                 GET_PRIVATE_JACK_POINTER_RET(_jack,0);
 429
 430                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 431
 432                 if (process_callback (nframes)) {
 433                         return 0;
 434                 }
 435
 436                 jack_cycle_signal (_priv_jack, 0);
 437         }
 438
 439         return 0;
 440 }
 441
 442 /** Method called by our ::process_thread when there is work to be done.
 443  *  @param nframes Number of frames to process.
 444  */
 445 int
 446 AudioEngine::process_callback (pframes_t nframes)
 447 {
 448         GET_PRIVATE_JACK_POINTER_RET(_jack,0);
 449         Glib::Mutex::Lock tm (_process_lock, Glib::TRY_LOCK);
 450
 451         PT_TIMING_REF;
 452         PT_TIMING_CHECK (1);
 453
 454         /// The number of frames that will have been processed when we've finished
 455         pframes_t next_processed_frames;
 456
 457         /* handle wrap around of total frames counter */
 458
 459         if (max_framepos - _processed_frames < nframes) {
 460                 next_processed_frames = nframes - (max_framepos - _processed_frames);
 461         } else {
 462                 next_processed_frames = _processed_frames + nframes;
 463         }
 464
 465         if (!tm.locked() || _session == 0) {
 466                 /* return having done nothing */
 467                 _processed_frames = next_processed_frames;
 468                 return 0;
 469         }
 470
 471         if (session_remove_pending) {
 472                 /* perform the actual session removal */
 473                 _session = 0;
 474                 session_remove_pending = false;
 475                 session_removed.signal();
 476                 _processed_frames = next_processed_frames;
 477                 return 0;
 478         }
 479
 480         /* tell all relevant objects that we're starting a new cycle */
 481
 482         InternalSend::CycleStart (nframes);
 483         Port::set_global_port_buffer_offset (0);
 484         Port::set_cycle_framecnt (nframes);
 485
 486         /* tell all Ports that we're starting a new cycle */
 487
 488         boost::shared_ptr<Ports> p = ports.reader();
 489
 490         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 491                 i->second->cycle_start (nframes);
 492         }
 493
 494         /* test if we are freewheeling and there are freewheel signals connected.
 495            ardour should act normally even when freewheeling unless /it/ is exporting */
 496
 497
 498         if (_freewheeling && !Freewheel.empty()) {
 499                 /* emit the Freewheel signal and stop freewheeling in the event of trouble
 500                  */
 501                 boost::optional<int> r = Freewheel (nframes);
 502                 if (r.get_value_or (0)) {
 503                         jack_set_freewheel (_priv_jack, false);
 504                 }
 505
 506         } else {
 507                 if (_session) {
 508                         _session->process (nframes);
 509                 }
 510         }
 511
 512         if (_freewheeling) {
 513                 return 0;
 514         }
 515
 516         if (!_running) {
 517                 _processed_frames = next_processed_frames;
 518                 return 0;
 519         }
 520
 521         if (last_monitor_check + monitor_check_interval < next_processed_frames) {
 522
 523                 boost::shared_ptr<Ports> p = ports.reader();
 524
 525                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 526
 527                         bool x;
 528
 529                         if (i->second->last_monitor() != (x = i->second->jack_monitoring_input ())) {
 530                                 i->second->set_last_monitor (x);
 531                                 /* XXX I think this is dangerous, due to
 532                                    a likely mutex in the signal handlers ...
 533                                 */
 534                                 i->second->MonitorInputChanged (x); /* EMIT SIGNAL */
 535                         }
 536                 }
 537                 last_monitor_check = next_processed_frames;
 538         }
 539
 540         if (_session->silent()) {
 541
 542                 boost::shared_ptr<Ports> p = ports.reader();
 543
 544                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 545
 546                         if (i->second->sends_output()) {
 547                                 i->second->get_buffer(nframes).silence(nframes);
 548                         }
 549                 }
 550         }
 551
 552         // Finalize ports
 553
 554         for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 555                 i->second->cycle_end (nframes);
 556         }
 557
 558         _processed_frames = next_processed_frames;
 559
 560         PT_TIMING_CHECK (2);
 561
 562         return 0;
 563 }
 564
 565 int
 566 AudioEngine::_sample_rate_callback (pframes_t nframes, void *arg)
 567 {
 568         return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
 569 }
 570
 571 int
 572 AudioEngine::jack_sample_rate_callback (pframes_t nframes)
 573 {
 574         _frame_rate = nframes;
 575         _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
 576
 577         /* check for monitor input change every 1/10th of second */
 578
 579         monitor_check_interval = nframes / 10;
 580         last_monitor_check = 0;
 581
 582         if (_session) {
 583                 _session->set_frame_rate (nframes);
 584         }
 585
 586         SampleRateChanged (nframes); /* EMIT SIGNAL */
 587
 588         return 0;
 589 }
 590
 591 void
 592 AudioEngine::jack_latency_callback (jack_latency_callback_mode_t mode)
 593 {
 594         if (_session) {
 595                 _session->update_latency (mode == JackPlaybackLatency);
 596         }
 597 }
 598
 599 int
 600 AudioEngine::_bufsize_callback (pframes_t nframes, void *arg)
 601 {
 602         return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
 603 }
 604
 605 int
 606 AudioEngine::jack_bufsize_callback (pframes_t nframes)
 607 {
 608         /* if the size has not changed, this should be a no-op */
 609
 610         if (nframes == _buffer_size) {
 611                 return 0;
 612         }
 613
 614         GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
 615
 616         _buffer_size = nframes;
 617         _usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
 618         last_monitor_check = 0;
 619
 620         if (jack_port_type_get_buffer_size) {
 621                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 622                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 623         } else {
 624
 625                 /* Old version of JACK.
 626
 627                    These crude guesses, see below where we try to get the right answers.
 628
 629                    Note that our guess for MIDI deliberatey tries to overestimate
 630                    by a little. It would be nicer if we could get the actual
 631                    size from a port, but we have to use this estimate in the
 632                    event that there are no MIDI ports currently. If there are
 633                    the value will be adjusted below.
 634                 */
 635
 636                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 637                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 638         }
 639
 640         {
 641                 Glib::Mutex::Lock lm (_process_lock);
 642
 643                 boost::shared_ptr<Ports> p = ports.reader();
 644
 645                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 646                         i->second->reset();
 647                 }
 648         }
 649
 650         if (_session) {
 651                 _session->set_block_size (_buffer_size);
 652         }
 653
 654         return 0;
 655 }
 656
 657 void
 658 AudioEngine::stop_metering_thread ()
 659 {
 660         if (m_meter_thread) {
 661                 g_atomic_int_set (&m_meter_exit, 1);
 662                 m_meter_thread->join ();
 663                 m_meter_thread = 0;
 664         }
 665 }
 666
 667 void
 668 AudioEngine::start_metering_thread ()
 669 {
 670         if (m_meter_thread == 0) {
 671                 g_atomic_int_set (&m_meter_exit, 0);
 672                 m_meter_thread = Glib::Thread::create (boost::bind (&AudioEngine::meter_thread, this),
 673                                                        500000, true, true, Glib::THREAD_PRIORITY_NORMAL);
 674         }
 675 }
 676
 677 void
 678 AudioEngine::meter_thread ()
 679 {
 680         pthread_set_name (X_("meter"));
 681
 682         while (true) {
 683                 Glib::usleep (10000); /* 1/100th sec interval */
 684                 if (g_atomic_int_get(&m_meter_exit)) {
 685                         break;
 686                 }
 687                 Metering::Meter ();
 688         }
 689 }
 690
 691 void
 692 AudioEngine::set_session (Session *s)
 693 {
 694         Glib::Mutex::Lock pl (_process_lock);
 695
 696         SessionHandlePtr::set_session (s);
 697
 698         if (_session) {
 699
 700                 start_metering_thread ();
 701
 702                 pframes_t blocksize = jack_get_buffer_size (_jack);
 703
 704                 /* page in as much of the session process code as we
 705                    can before we really start running.
 706                 */
 707
 708                 boost::shared_ptr<Ports> p = ports.reader();
 709
 710                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 711                         i->second->cycle_start (blocksize);
 712                 }
 713
 714                 _session->process (blocksize);
 715                 _session->process (blocksize);
 716                 _session->process (blocksize);
 717                 _session->process (blocksize);
 718                 _session->process (blocksize);
 719                 _session->process (blocksize);
 720                 _session->process (blocksize);
 721                 _session->process (blocksize);
 722
 723                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 724                         i->second->cycle_end (blocksize);
 725                 }
 726         }
 727 }
 728
 729 void
 730 AudioEngine::remove_session ()
 731 {
 732         Glib::Mutex::Lock lm (_process_lock);
 733
 734         if (_running) {
 735
 736                 stop_metering_thread ();
 737
 738                 if (_session) {
 739                         session_remove_pending = true;
 740                         session_removed.wait(_process_lock);
 741                 }
 742
 743         } else {
 744                 SessionHandlePtr::set_session (0);
 745         }
 746
 747         remove_all_ports ();
 748 }
 749
 750 void
 751 AudioEngine::port_registration_failure (const std::string& portname)
 752 {
 753         GET_PRIVATE_JACK_POINTER (_jack);
 754         string full_portname = jack_client_name;
 755         full_portname += ':';
 756         full_portname += portname;
 757
 758
 759         jack_port_t* p = jack_port_by_name (_priv_jack, full_portname.c_str());
 760         string reason;
 761
 762         if (p) {
 763                 reason = string_compose (_("a port with the name \"%1\" already exists: check for duplicated track/bus names"), portname);
 764         } else {
 765                 reason = string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME);
 766         }
 767
 768         throw PortRegistrationFailure (string_compose (_("AudioEngine: cannot register port \"%1\": %2"), portname, reason).c_str());
 769 }
 770
 771 boost::shared_ptr<Port>
 772 AudioEngine::register_port (DataType dtype, const string& portname, bool input)
 773 {
 774         boost::shared_ptr<Port> newport;
 775
 776         try {
 777                 if (dtype == DataType::AUDIO) {
 778                         newport.reset (new AudioPort (portname, (input ? Port::IsInput : Port::IsOutput)));
 779                 } else if (dtype == DataType::MIDI) {
 780                         newport.reset (new MidiPort (portname, (input ? Port::IsInput : Port::IsOutput)));
 781                 } else {
 782                         throw PortRegistrationFailure("unable to create port (unknown type)");
 783                 }
 784
 785                 RCUWriter<Ports> writer (ports);
 786                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 787                 ps->insert (make_pair (make_port_name_relative (portname), newport));
 788
 789                 /* writer goes out of scope, forces update */
 790
 791                 return newport;
 792         }
 793
 794         catch (PortRegistrationFailure& err) {
 795                 throw err;
 796         } catch (std::exception& e) {
 797                 throw PortRegistrationFailure(string_compose(
 798                                 _("unable to create port: %1"), e.what()).c_str());
 799         } catch (...) {
 800                 throw PortRegistrationFailure("unable to create port (unknown error)");
 801         }
 802 }
 803
 804 boost::shared_ptr<Port>
 805 AudioEngine::register_input_port (DataType type, const string& portname)
 806 {
 807         return register_port (type, portname, true);
 808 }
 809
 810 boost::shared_ptr<Port>
 811 AudioEngine::register_output_port (DataType type, const string& portname)
 812 {
 813         return register_port (type, portname, false);
 814 }
 815
 816 int
 817 AudioEngine::unregister_port (boost::shared_ptr<Port> port)
 818 {
 819         /* caller must hold process lock */
 820
 821         if (!_running) {
 822                 /* probably happening when the engine has been halted by JACK,
 823                    in which case, there is nothing we can do here.
 824                    */
 825                 return 0;
 826         }
 827
 828         {
 829                 RCUWriter<Ports> writer (ports);
 830                 boost::shared_ptr<Ports> ps = writer.get_copy ();
 831                 Ports::iterator x = ps->find (make_port_name_relative (port->name()));
 832
 833                 if (x != ps->end()) {
 834                         ps->erase (x);
 835                 }
 836
 837                 /* writer goes out of scope, forces update */
 838         }
 839
 840         ports.flush ();
 841
 842         return 0;
 843 }
 844
 845 int
 846 AudioEngine::connect (const string& source, const string& destination)
 847 {
 848         int ret;
 849
 850         if (!_running) {
 851                 if (!_has_run) {
 852                         fatal << _("connect called before engine was started") << endmsg;
 853                         /*NOTREACHED*/
 854                 } else {
 855                         return -1;
 856                 }
 857         }
 858
 859         string s = make_port_name_non_relative (source);
 860         string d = make_port_name_non_relative (destination);
 861
 862
 863         boost::shared_ptr<Port> src = get_port_by_name (s);
 864         boost::shared_ptr<Port> dst = get_port_by_name (d);
 865
 866         if (src) {
 867                 ret = src->connect (d);
 868         } else if (dst) {
 869                 ret = dst->connect (s);
 870         } else {
 871                 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
 872                 ret = -1;
 873         }
 874
 875         if (ret > 0) {
 876                 /* already exists - no error, no warning */
 877         } else if (ret < 0) {
 878                 error << string_compose(_("AudioEngine: cannot connect %1 (%2) to %3 (%4)"),
 879                                         source, s, destination, d)
 880                       << endmsg;
 881         }
 882
 883         return ret;
 884 }
 885
 886 int
 887 AudioEngine::disconnect (const string& source, const string& destination)
 888 {
 889         int ret;
 890
 891         if (!_running) {
 892                 if (!_has_run) {
 893                         fatal << _("disconnect called before engine was started") << endmsg;
 894                         /*NOTREACHED*/
 895                 } else {
 896                         return -1;
 897                 }
 898         }
 899
 900         string s = make_port_name_non_relative (source);
 901         string d = make_port_name_non_relative (destination);
 902
 903         boost::shared_ptr<Port> src = get_port_by_name (s);
 904         boost::shared_ptr<Port> dst = get_port_by_name (d);
 905
 906         if (src) {
 907                         ret = src->disconnect (d);
 908         } else if (dst) {
 909                         ret = dst->disconnect (s);
 910         } else {
 911                 /* neither port is known to us, and this API isn't intended for use as a general patch bay */
 912                 ret = -1;
 913         }
 914         return ret;
 915 }
 916
 917 int
 918 AudioEngine::disconnect (boost::shared_ptr<Port> port)
 919 {
 920         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
 921
 922         if (!_running) {
 923                 if (!_has_run) {
 924                         fatal << _("disconnect called before engine was started") << endmsg;
 925                         /*NOTREACHED*/
 926                 } else {
 927                         return -1;
 928                 }
 929         }
 930
 931         return port->disconnect_all ();
 932 }
 933
 934 ARDOUR::framecnt_t
 935 AudioEngine::frame_rate () const
 936 {
 937         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
 938         if (_frame_rate == 0) {
 939                 return (_frame_rate = jack_get_sample_rate (_priv_jack));
 940         } else {
 941                 return _frame_rate;
 942         }
 943 }
 944
 945 size_t
 946 AudioEngine::raw_buffer_size (DataType t)
 947 {
 948         std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
 949         return (s != _raw_buffer_sizes.end()) ? s->second : 0;
 950 }
 951
 952 ARDOUR::pframes_t
 953 AudioEngine::frames_per_cycle () const
 954 {
 955         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
 956         if (_buffer_size == 0) {
 957                 return jack_get_buffer_size (_jack);
 958         } else {
 959                 return _buffer_size;
 960         }
 961 }
 962
 963 /** @param name Full or short name of port
 964  *  @return Corresponding Port or 0.
 965  */
 966
 967 boost::shared_ptr<Port>
 968 AudioEngine::get_port_by_name (const string& portname)
 969 {
 970         if (!_running) {
 971                 if (!_has_run) {
 972                         fatal << _("get_port_by_name() called before engine was started") << endmsg;
 973                         /*NOTREACHED*/
 974                 } else {
 975                         boost::shared_ptr<Port> ();
 976                 }
 977         }
 978
 979         if (!port_is_mine (portname)) {
 980                 /* not an ardour port */
 981                 return boost::shared_ptr<Port> ();
 982         }
 983
 984         boost::shared_ptr<Ports> pr = ports.reader();
 985         std::string rel = make_port_name_relative (portname);
 986         Ports::iterator x = pr->find (rel);
 987
 988         if (x != pr->end()) {
 989                 /* its possible that the port was renamed by some 3rd party and
 990                    we don't know about it. check for this (the check is quick
 991                    and cheap), and if so, rename the port (which will alter
 992                    the port map as a side effect).
 993                 */
 994                 const std::string check = make_port_name_relative (jack_port_name (x->second->jack_port()));
 995                 if (check != rel) {
 996                         x->second->set_name (check);
 997                 }
 998                 return x->second;
 999         }
1000
1001         return boost::shared_ptr<Port> ();
1002 }
1003
1004 void
1005 AudioEngine::port_renamed (const std::string& old_relative_name, const std::string& new_relative_name)
1006 {
1007         RCUWriter<Ports> writer (ports);
1008         boost::shared_ptr<Ports> p = writer.get_copy();
1009         Ports::iterator x = p->find (old_relative_name);
1010
1011         if (x != p->end()) {
1012                 boost::shared_ptr<Port> port = x->second;
1013                 p->erase (x);
1014                 p->insert (make_pair (new_relative_name, port));
1015         }
1016 }
1017
1018 const char **
1019 AudioEngine::get_ports (const string& port_name_pattern, const string& type_name_pattern, uint32_t flags)
1020 {
1021         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
1022         if (!_running) {
1023                 if (!_has_run) {
1024                         fatal << _("get_ports called before engine was started") << endmsg;
1025                         /*NOTREACHED*/
1026                 } else {
1027                         return 0;
1028                 }
1029         }
1030         return jack_get_ports (_priv_jack, port_name_pattern.c_str(), type_name_pattern.c_str(), flags);
1031 }
1032
1033 void
1034 AudioEngine::halted_info (jack_status_t code, const char* reason, void *arg)
1035 {
1036         /* called from jack shutdown handler  */
1037
1038         AudioEngine* ae = static_cast<AudioEngine *> (arg);
1039         bool was_running = ae->_running;
1040
1041         ae->stop_metering_thread ();
1042
1043         ae->_running = false;
1044         ae->_buffer_size = 0;
1045         ae->_frame_rate = 0;
1046         ae->_jack = 0;
1047
1048         if (was_running) {
1049 #ifdef HAVE_JACK_ON_INFO_SHUTDOWN
1050                 switch (code) {
1051                 case JackBackendError:
1052                         ae->Halted(reason); /* EMIT SIGNAL */
1053                         break;
1054                 default:
1055                         ae->Halted(""); /* EMIT SIGNAL */
1056                 }
1057 #else
1058                 ae->Halted(""); /* EMIT SIGNAL */
1059 #endif
1060         }
1061 }
1062
1063 void
1064 AudioEngine::halted (void *arg)
1065 {
1066         cerr << "HALTED by JACK\n";
1067
1068         /* called from jack shutdown handler  */
1069
1070         AudioEngine* ae = static_cast<AudioEngine *> (arg);
1071         bool was_running = ae->_running;
1072
1073         ae->stop_metering_thread ();
1074
1075         ae->_running = false;
1076         ae->_buffer_size = 0;
1077         ae->_frame_rate = 0;
1078         ae->_jack = 0;
1079
1080         if (was_running) {
1081                 ae->Halted(""); /* EMIT SIGNAL */
1082                 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
1083         }
1084 }
1085
1086 void
1087 AudioEngine::died ()
1088 {
1089         /* called from a signal handler for SIGPIPE */
1090
1091         stop_metering_thread ();
1092
1093         _running = false;
1094         _buffer_size = 0;
1095         _frame_rate = 0;
1096         _jack = 0;
1097 }
1098
1099 bool
1100 AudioEngine::can_request_hardware_monitoring ()
1101 {
1102         GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1103         const char ** ports;
1104
1105         if ((ports = jack_get_ports (_priv_jack, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortCanMonitor)) == 0) {
1106                 return false;
1107         }
1108
1109         free (ports);
1110
1111         return true;
1112 }
1113
1114 ChanCount
1115 AudioEngine::n_physical (unsigned long flags) const
1116 {
1117         ChanCount c;
1118
1119         GET_PRIVATE_JACK_POINTER_RET (_jack, c);
1120
1121         const char ** ports = jack_get_ports (_priv_jack, NULL, NULL, JackPortIsPhysical | flags);
1122         if (ports == 0) {
1123                 return c;
1124         }
1125
1126         for (uint32_t i = 0; ports[i]; ++i) {
1127                 if (!strstr (ports[i], "Midi-Through")) {
1128                         DataType t (jack_port_type (jack_port_by_name (_jack, ports[i])));
1129                         c.set (t, c.get (t) + 1);
1130                 }
1131         }
1132
1133         free (ports);
1134
1135         return c;
1136 }
1137
1138 ChanCount
1139 AudioEngine::n_physical_inputs () const
1140 {
1141         return n_physical (JackPortIsInput);
1142 }
1143
1144 ChanCount
1145 AudioEngine::n_physical_outputs () const
1146 {
1147         return n_physical (JackPortIsOutput);
1148 }
1149
1150 void
1151 AudioEngine::get_physical (DataType type, unsigned long flags, vector<string>& phy)
1152 {
1153         GET_PRIVATE_JACK_POINTER (_jack);
1154         const char ** ports;
1155
1156         if ((ports = jack_get_ports (_priv_jack, NULL, type.to_jack_type(), JackPortIsPhysical | flags)) == 0) {
1157                 return;
1158         }
1159
1160         if (ports) {
1161                 for (uint32_t i = 0; ports[i]; ++i) {
1162                         if (strstr (ports[i], "Midi-Through")) {
1163                                 continue;
1164                         }
1165                         phy.push_back (ports[i]);
1166                 }
1167                 free (ports);
1168         }
1169 }
1170
1171 /** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
1172  *  a physical input connector.
1173  */
1174 void
1175 AudioEngine::get_physical_inputs (DataType type, vector<string>& ins)
1176 {
1177         get_physical (type, JackPortIsOutput, ins);
1178 }
1179
1180 /** Get physical ports for which JackPortIsInput is set; ie those that correspond to
1181  *  a physical output connector.
1182  */
1183 void
1184 AudioEngine::get_physical_outputs (DataType type, vector<string>& outs)
1185 {
1186         get_physical (type, JackPortIsInput, outs);
1187 }
1188
1189 void
1190 AudioEngine::transport_stop ()
1191 {
1192         GET_PRIVATE_JACK_POINTER (_jack);
1193         jack_transport_stop (_priv_jack);
1194 }
1195
1196 void
1197 AudioEngine::transport_start ()
1198 {
1199         GET_PRIVATE_JACK_POINTER (_jack);
1200         jack_transport_start (_priv_jack);
1201 }
1202
1203 void
1204 AudioEngine::transport_locate (framepos_t where)
1205 {
1206         GET_PRIVATE_JACK_POINTER (_jack);
1207         jack_transport_locate (_priv_jack, where);
1208 }
1209
1210 AudioEngine::TransportState
1211 AudioEngine::transport_state ()
1212 {
1213         GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
1214         jack_position_t pos;
1215         return (TransportState) jack_transport_query (_priv_jack, &pos);
1216 }
1217
1218 int
1219 AudioEngine::reset_timebase ()
1220 {
1221         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1222         if (_session) {
1223                 if (_session->config.get_jack_time_master()) {
1224                         return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
1225                 } else {
1226                         return jack_release_timebase (_jack);
1227                 }
1228         }
1229         return 0;
1230 }
1231
1232 int
1233 AudioEngine::freewheel (bool onoff)
1234 {
1235         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1236
1237         if (onoff != _freewheeling) {
1238                 return jack_set_freewheel (_priv_jack, onoff);
1239
1240         } else {
1241                 /* already doing what has been asked for */
1242                 return 0;
1243         }
1244 }
1245
1246 void
1247 AudioEngine::remove_all_ports ()
1248 {
1249         /* make sure that JACK callbacks that will be invoked as we cleanup
1250          * ports know that they have nothing to do.
1251          */
1252
1253         port_remove_in_progress = true;
1254
1255         /* process lock MUST be held by caller
1256         */
1257
1258         {
1259                 RCUWriter<Ports> writer (ports);
1260                 boost::shared_ptr<Ports> ps = writer.get_copy ();
1261                 ps->clear ();
1262         }
1263
1264         /* clear dead wood list in RCU */
1265
1266         ports.flush ();
1267
1268         port_remove_in_progress = false;
1269 }
1270
1271 int
1272 AudioEngine::connect_to_jack (string client_name, string session_uuid)
1273 {
1274         EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
1275         boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
1276         jack_options_t options = JackNullOption;
1277         jack_status_t status;
1278         const char *server_name = NULL;
1279
1280         /* revert all environment settings back to whatever they were when ardour started
1281          */
1282
1283         if (global_epa) {
1284                 current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
1285                 global_epa->restore ();
1286         }
1287
1288         jack_client_name = client_name; /* might be reset below */
1289 #ifdef HAVE_JACK_SESSION
1290         if (! session_uuid.empty())
1291             _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
1292         else
1293 #endif
1294             _jack = jack_client_open (jack_client_name.c_str(), options, &status, server_name);
1295
1296         if (_jack == NULL) {
1297                 // error message is not useful here
1298                 return -1;
1299         }
1300
1301         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1302
1303         if (status & JackNameNotUnique) {
1304                 jack_client_name = jack_get_client_name (_priv_jack);
1305         }
1306
1307         return 0;
1308 }
1309
1310 int
1311 AudioEngine::disconnect_from_jack ()
1312 {
1313         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1314
1315         if (_running) {
1316                 stop_metering_thread ();
1317         }
1318
1319         {
1320                 Glib::Mutex::Lock lm (_process_lock);
1321                 jack_client_close (_priv_jack);
1322                 _jack = 0;
1323         }
1324
1325         _buffer_size = 0;
1326         _frame_rate = 0;
1327         _raw_buffer_sizes.clear();
1328
1329         if (_running) {
1330                 _running = false;
1331                 Stopped(); /* EMIT SIGNAL */
1332                 MIDI::Port::JackHalted (); /* EMIT SIGNAL */
1333         }
1334
1335         return 0;
1336 }
1337
1338 int
1339 AudioEngine::reconnect_to_jack ()
1340 {
1341         if (_running) {
1342                 disconnect_from_jack ();
1343                 /* XXX give jackd a chance */
1344                 Glib::usleep (250000);
1345         }
1346
1347         if (connect_to_jack (jack_client_name, "")) {
1348                 error << _("failed to connect to JACK") << endmsg;
1349                 return -1;
1350         }
1351
1352         Ports::iterator i;
1353
1354         boost::shared_ptr<Ports> p = ports.reader ();
1355
1356         for (i = p->begin(); i != p->end(); ++i) {
1357                 if (i->second->reestablish ()) {
1358                         break;
1359                 }
1360         }
1361
1362         if (i != p->end()) {
1363                 /* failed */
1364                 remove_all_ports ();
1365                 return -1;
1366         }
1367
1368         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
1369
1370         MIDI::Manager::instance()->reestablish (_priv_jack);
1371
1372         if (_session) {
1373                 _session->reset_jack_connection (_priv_jack);
1374                 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
1375                 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
1376         }
1377
1378         last_monitor_check = 0;
1379
1380         set_jack_callbacks ();
1381
1382         if (jack_activate (_priv_jack) == 0) {
1383                 _running = true;
1384                 _has_run = true;
1385         } else {
1386                 return -1;
1387         }
1388
1389         /* re-establish connections */
1390
1391         for (i = p->begin(); i != p->end(); ++i) {
1392                 i->second->reconnect ();
1393         }
1394
1395         MIDI::Manager::instance()->reconnect ();
1396
1397         Running (); /* EMIT SIGNAL*/
1398
1399         start_metering_thread ();
1400
1401         return 0;
1402 }
1403
1404 int
1405 AudioEngine::request_buffer_size (pframes_t nframes)
1406 {
1407         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
1408
1409         if (nframes == jack_get_buffer_size (_priv_jack)) {
1410                 return 0;
1411         }
1412
1413         return jack_set_buffer_size (_priv_jack, nframes);
1414 }
1415
1416 string
1417 AudioEngine::make_port_name_relative (string portname) const
1418 {
1419         string::size_type len;
1420         string::size_type n;
1421
1422         len = portname.length();
1423
1424         for (n = 0; n < len; ++n) {
1425                 if (portname[n] == ':') {
1426                         break;
1427                 }
1428         }
1429
1430         if ((n != len) && (portname.substr (0, n) == jack_client_name)) {
1431                 return portname.substr (n+1);
1432         }
1433
1434         return portname;
1435 }
1436
1437 string
1438 AudioEngine::make_port_name_non_relative (string portname) const
1439 {
1440         string str;
1441
1442         if (portname.find_first_of (':') != string::npos) {
1443                 return portname;
1444         }
1445
1446         str  = jack_client_name;
1447         str += ':';
1448         str += portname;
1449
1450         return str;
1451 }
1452
1453 bool
1454 AudioEngine::port_is_mine (const string& portname) const
1455 {
1456         if (portname.find_first_of (':') != string::npos) {
1457                 if (portname.substr (0, jack_client_name.length ()) != jack_client_name) {
1458                         return false;
1459                 }
1460         }
1461         return true;
1462 }
1463
1464 bool
1465 AudioEngine::is_realtime () const
1466 {
1467         GET_PRIVATE_JACK_POINTER_RET (_jack,false);
1468         return jack_is_realtime (_priv_jack);
1469 }
1470
1471 int
1472 AudioEngine::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
1473 {
1474         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
1475         ThreadData* td = new ThreadData (this, f, stacksize);
1476
1477         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
1478                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
1479                 return -1;
1480         }
1481
1482         return 0;
1483 }
1484
1485 void*
1486 AudioEngine::_start_process_thread (void* arg)
1487 {
1488         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
1489         boost::function<void()> f = td->f;
1490         delete td;
1491
1492         f ();
1493
1494         return 0;
1495 }
1496
1497 bool
1498 AudioEngine::port_is_physical (const std::string& portname) const
1499 {
1500         GET_PRIVATE_JACK_POINTER_RET(_jack, false);
1501
1502         jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1503
1504         if (!port) {
1505                 return false;
1506         }
1507
1508         return jack_port_flags (port) & JackPortIsPhysical;
1509 }
1510
1511 void
1512 AudioEngine::request_jack_monitors_input (const std::string& portname, bool yn) const
1513 {
1514         GET_PRIVATE_JACK_POINTER(_jack);
1515
1516         jack_port_t *port = jack_port_by_name (_priv_jack, portname.c_str());
1517
1518         if (!port) {
1519                 return;
1520         }
1521
1522         jack_port_request_monitor (port, yn);
1523 }
1524
1525 void
1526 AudioEngine::update_latencies ()
1527 {
1528         if (jack_recompute_total_latencies) {
1529                 GET_PRIVATE_JACK_POINTER (_jack);
1530                 jack_recompute_total_latencies (_priv_jack);
1531         }
1532 }
1533
1534 void
1535 AudioEngine::destroy ()
1536 {
1537         delete _instance;
1538         _instance = 0;
1539 }