libs/ardour/jack_audiobackend.cc

   1 #include "ardour/jack_audiobackend.h"
   2
   3 #define GET_PRIVATE_JACK_POINTER(j)  jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
   4 #define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
   5
   6 int
   7 JACKAudioBackend::start ()
   8 {
   9         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
  10
  11         if (!_running) {
  12
  13                 if (!jack_port_type_get_buffer_size) {
  14                         warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
  15                 }
  16
  17                 if (_session) {
  18                         BootMessage (_("Connect session to engine"));
  19                         _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
  20                 }
  21
  22                 /* a proxy for whether jack_activate() will definitely call the buffer size
  23                  * callback. with older versions of JACK, this function symbol will be null.
  24                  * this is reliable, but not clean.
  25                  */
  26
  27                 if (!jack_port_type_get_buffer_size) {
  28                         jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
  29                 }
  30
  31                 _processed_frames = 0;
  32                 last_monitor_check = 0;
  33
  34                 set_jack_callbacks ();
  35
  36                 if (jack_activate (_priv_jack) == 0) {
  37                         _running = true;
  38                         _has_run = true;
  39                         Running(); /* EMIT SIGNAL */
  40                 } else {
  41                         // error << _("cannot activate JACK client") << endmsg;
  42                 }
  43         }
  44
  45         return _running ? 0 : -1;
  46 }
  47
  48 int
  49 JACKAudioBackend::stop ()
  50 {
  51         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
  52
  53         {
  54                 Glib::Threads::Mutex::Lock lm (_process_lock);
  55                 jack_client_close (_priv_jack);
  56                 _jack = 0;
  57         }
  58
  59         _buffer_size = 0;
  60         _frame_rate = 0;
  61         _raw_buffer_sizes.clear();
  62
  63         return 0;
  64 }
  65
  66 int
  67 JACKAudioBackend::pause ()
  68 {
  69         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
  70
  71         if (_priv_jack) {
  72                 jack_deactivate (_priv_jack);
  73         }
  74
  75         return 0;
  76 }
  77
  78 int
  79 JACKAudioBackend::freewheel (bool onoff)
  80 {
  81         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
  82
  83         if (onoff == _freewheeling) {
  84                 /* already doing what has been asked for */
  85
  86                 return 0;
  87         }
  88
  89         return jack_set_freewheel (_priv_jack, onoff);
  90 }
  91
  92 int
  93 JACKAudioBackend::set_parameters (const Parameters& params)
  94 {
  95         return 0;
  96 }
  97
  98 int
  99 JACKAudioBackend::get_parameters (Parameters& params) const
 100 {
 101         return 0;
 102 }
 103
 104 /* parameters */
 105
 106 ARDOUR::pframes_t
 107 AudioEngine::frames_per_cycle () const
 108 {
 109         GET_PRIVATE_JACK_POINTER_RET (_jack,0);
 110         if (_buffer_size == 0) {
 111                 return jack_get_buffer_size (_jack);
 112         } else {
 113                 return _buffer_size;
 114         }
 115 }
 116
 117 ARDOUR::framecnt_t
 118 AudioEngine::frame_rate () const
 119 {
 120         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
 121         if (_frame_rate == 0) {
 122                 return (_frame_rate = jack_get_sample_rate (_priv_jack));
 123         } else {
 124                 return _frame_rate;
 125         }
 126 }
 127
 128 size_t
 129 AudioEngine::raw_buffer_size (DataType t)
 130 {
 131         std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
 132         return (s != _raw_buffer_sizes.end()) ? s->second : 0;
 133 }
 134
 135
 136
 137 /*--- private support methods ---*/
 138
 139 int
 140 JACKAudioBackend::connect_to_jack (string client_name, string session_uuid)
 141 {
 142         EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
 143         boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
 144         jack_status_t status;
 145
 146         /* revert all environment settings back to whatever they were when ardour started
 147          */
 148
 149         if (global_epa) {
 150                 current_epa.reset (new EnvironmentalProtectionAgency(true)); /* will restore settings when we leave scope */
 151                 global_epa->restore ();
 152         }
 153
 154         jack_client_name = client_name; /* might be reset below */
 155 #ifdef HAVE_JACK_SESSION
 156         if (!session_uuid.empty())
 157             _jack = jack_client_open (jack_client_name.c_str(), JackSessionID, &status, session_uuid.c_str());
 158         else
 159 #endif
 160         _jack = jack_client_open (jack_client_name.c_str(), JackNullOption, &status, 0);
 161
 162         if (_jack == NULL) {
 163                 // error message is not useful here
 164                 return -1;
 165         }
 166
 167         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 168
 169         if (status & JackNameNotUnique) {
 170                 jack_client_name = jack_get_client_name (_priv_jack);
 171         }
 172
 173         return 0;
 174 }
 175
 176 int
 177 JACKAudioBackend::disconnect_from_jack ()
 178 {
 179
 180 int
 181 JACKAudioBackend::reconnect_to_jack ()
 182 {
 183         if (_running) {
 184                 disconnect_from_jack ();
 185                 /* XXX give jackd a chance */
 186                 Glib::usleep (250000);
 187         }
 188
 189         if (connect_to_jack (jack_client_name, "")) {
 190                 error << _("failed to connect to JACK") << endmsg;
 191                 return -1;
 192         }
 193
 194         Ports::iterator i;
 195
 196         boost::shared_ptr<Ports> p = ports.reader ();
 197
 198         for (i = p->begin(); i != p->end(); ++i) {
 199                 if (i->second->reestablish ()) {
 200                         break;
 201                 }
 202         }
 203
 204         if (i != p->end()) {
 205                 /* failed */
 206                 remove_all_ports ();
 207                 return -1;
 208         }
 209
 210         GET_PRIVATE_JACK_POINTER_RET (_jack,-1);
 211
 212         MIDI::Manager::instance()->reestablish (_priv_jack);
 213
 214         if (_session) {
 215                 _session->reset_jack_connection (_priv_jack);
 216                 jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
 217                 _session->set_frame_rate (jack_get_sample_rate (_priv_jack));
 218         }
 219
 220         last_monitor_check = 0;
 221
 222         set_jack_callbacks ();
 223
 224         if (jack_activate (_priv_jack) == 0) {
 225                 _running = true;
 226                 _has_run = true;
 227         } else {
 228                 return -1;
 229         }
 230
 231         /* re-establish connections */
 232
 233         for (i = p->begin(); i != p->end(); ++i) {
 234                 i->second->reconnect ();
 235         }
 236
 237         MIDI::Manager::instance()->reconnect ();
 238
 239         Running (); /* EMIT SIGNAL*/
 240
 241         start_metering_thread ();
 242
 243         return 0;
 244 }
 245
 246 int
 247 JACKAudioBackend::request_buffer_size (pframes_t nframes)
 248 {
 249         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 250
 251         if (nframes == jack_get_buffer_size (_priv_jack)) {
 252                 return 0;
 253         }
 254
 255         return jack_set_buffer_size (_priv_jack, nframes);
 256 }
 257
 258 /* --- TRANSPORT STATE MANAGEMENT --- */
 259
 260 void
 261 JACKAudioBackend::transport_stop ()
 262 {
 263         GET_PRIVATE_JACK_POINTER (_jack);
 264         jack_transport_stop (_priv_jack);
 265 }
 266
 267 void
 268 JACKAudioBackend::transport_start ()
 269 {
 270         GET_PRIVATE_JACK_POINTER (_jack);
 271         jack_transport_start (_priv_jack);
 272 }
 273
 274 void
 275 JACKAudioBackend::transport_locate (framepos_t where)
 276 {
 277         GET_PRIVATE_JACK_POINTER (_jack);
 278         jack_transport_locate (_priv_jack, where);
 279 }
 280
 281 framepos_t
 282 JACKAudioBackend::transport_frame () const
 283 {
 284         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
 285         return jack_get_current_transport_frame (_priv_jack);
 286 }
 287
 288 JACKAudioBackend::TransportState
 289 JACKAudioBackend::transport_state ()
 290 {
 291         GET_PRIVATE_JACK_POINTER_RET (_jack, ((TransportState) JackTransportStopped));
 292         jack_position_t pos;
 293         return (TransportState) jack_transport_query (_priv_jack, &pos);
 294 }
 295
 296 int
 297 JACKAudioBackend::set_time_master (bool yn)
 298 {
 299         GET_PRIVATE_JACK_POINTER_RET (_jack, -1);
 300         if (yn) {
 301                 return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 302         } else {
 303                 return jack_release_timebase (_jack);
 304         }
 305 }
 306
 307 /* process-time */
 308
 309 framecnt_t frame_rate () const;
 310 pframes_t frames_per_cycle () const;
 311
 312 size_t raw_buffer_size(DataType t);
 313
 314 int usecs_per_cycle () const { return _usecs_per_cycle; }
 315
 316 bool
 317 JACKAudioBackend::get_sync_offset (pframes_t& offset) const
 318 {
 319
 320 #ifdef HAVE_JACK_VIDEO_SUPPORT
 321
 322         GET_PRIVATE_JACK_POINTER_RET (_jack, false);
 323
 324         jack_position_t pos;
 325
 326         if (_priv_jack) {
 327                 (void) jack_transport_query (_priv_jack, &pos);
 328
 329                 if (pos.valid & JackVideoFrameOffset) {
 330                         offset = pos.video_offset;
 331                         return true;
 332                 }
 333         }
 334 #else
 335         /* keep gcc happy */
 336         offset = 0;
 337 #endif
 338
 339         return false;
 340 }
 341
 342 pframes_t
 343 JACKAudioBackend::frames_since_cycle_start ()
 344 {
 345         jack_client_t* _priv_jack = _jack;
 346         if (!_running || !_priv_jack) {
 347                 return 0;
 348         }
 349         return jack_frames_since_cycle_start (_priv_jack);
 350 }
 351
 352 pframes_t
 353 JACKAudioBackend::frame_time ()
 354 {
 355         jack_client_t* _priv_jack = _jack;
 356         if (!_running || !_priv_jack) {
 357                 return 0;
 358         }
 359         return jack_frame_time (_priv_jack);
 360 }
 361
 362 pframes_t
 363 JACKAudioBackend::frame_time_at_cycle_start ()
 364 {
 365         jack_client_t* _priv_jack = _jack;
 366         if (!_running || !_priv_jack) {
 367                 return 0;
 368         }
 369         return jack_last_frame_time (_priv_jack);
 370 }
 371
 372 /* JACK Callbacks */
 373
 374 static void
 375 ardour_jack_error (const char* msg)
 376 {
 377         error << "JACK: " << msg << endmsg;
 378 }
 379
 380 void
 381 JACKAudioBackend::set_jack_callbacks ()
 382 {
 383         GET_PRIVATE_JACK_POINTER (_jack);
 384
 385         if (jack_on_info_shutdown) {
 386                 jack_on_info_shutdown (_priv_jack, halted_info, this);
 387         } else {
 388                 jack_on_shutdown (_priv_jack, halted, this);
 389         }
 390
 391         jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
 392         jack_set_process_thread (_priv_jack, _process_thread, this);
 393         jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
 394         jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
 395         jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
 396         jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
 397         jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
 398         jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
 399         jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
 400         jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
 401
 402         if (_session && _session->config.get_jack_time_master()) {
 403                 jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
 404         }
 405
 406 #ifdef HAVE_JACK_SESSION
 407         if( jack_set_session_callback)
 408                 jack_set_session_callback (_priv_jack, _session_callback, this);
 409 #endif
 410
 411         if (jack_set_latency_callback) {
 412                 jack_set_latency_callback (_priv_jack, _latency_callback, this);
 413         }
 414
 415         jack_set_error_function (ardour_jack_error);
 416 }
 417
 418 void
 419 JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 420                                       jack_position_t* pos, int new_position, void *arg)
 421 {
 422         static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
 423 }
 424
 425 void
 426 JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
 427                                      jack_position_t* pos, int new_position)
 428 {
 429         if (_jack && _session && _session->synced_to_jack()) {
 430                 _session->jack_timebase_callback (state, nframes, pos, new_position);
 431         }
 432 }
 433
 434 int
 435 JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
 436 {
 437         return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
 438 }
 439
 440 int
 441 JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
 442 {
 443         if (_jack && _session) {
 444                 return _session->jack_sync_callback (state, pos);
 445         }
 446
 447         return true;
 448 }
 449
 450 int
 451 JACKAudioBackend::_xrun_callback (void *arg)
 452 {
 453         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 454         if (ae->connected()) {
 455                 ae->Xrun (); /* EMIT SIGNAL */
 456         }
 457         return 0;
 458 }
 459
 460 #ifdef HAVE_JACK_SESSION
 461 void
 462 JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
 463 {
 464         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 465         if (ae->connected()) {
 466                 ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
 467         }
 468 }
 469 #endif
 470
 471 int
 472 JACKAudioBackend::_graph_order_callback (void *arg)
 473 {
 474         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 475
 476         if (ae->connected() && !ae->port_remove_in_progress) {
 477                 ae->GraphReordered (); /* EMIT SIGNAL */
 478         }
 479
 480         return 0;
 481 }
 482
 483 void
 484 JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
 485 {
 486         static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
 487 }
 488
 489 void
 490 JACKAudioBackend::freewheel_callback (int onoff)
 491 {
 492         _freewheeling = onoff;
 493
 494         if (onoff) {
 495                 _pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
 496                 MIDI::Manager::instance()->mmc()->enable_send (false);
 497         } else {
 498                 MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
 499         }
 500 }
 501
 502 void
 503 JACKAudioBackend::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
 504 {
 505         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 506
 507         if (!ae->port_remove_in_progress) {
 508                 ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
 509         }
 510 }
 511
 512 void
 513 JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
 514 {
 515         return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
 516 }
 517
 518 void
 519 JACKAudioBackend::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
 520 {
 521         AudioEngine* ae = static_cast<AudioEngine*> (arg);
 522         ae->connect_callback (id_a, id_b, conn);
 523 }
 524
 525 void
 526 JACKAudioBackend::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn)
 527 {
 528         if (port_remove_in_progress) {
 529                 return;
 530         }
 531
 532         GET_PRIVATE_JACK_POINTER (_jack);
 533
 534         jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
 535         jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
 536
 537         boost::shared_ptr<Port> port_a;
 538         boost::shared_ptr<Port> port_b;
 539         Ports::iterator x;
 540         boost::shared_ptr<Ports> pr = ports.reader ();
 541
 542
 543         x = pr->find (make_port_name_relative (jack_port_name (jack_port_a)));
 544         if (x != pr->end()) {
 545                 port_a = x->second;
 546         }
 547
 548         x = pr->find (make_port_name_relative (jack_port_name (jack_port_b)));
 549         if (x != pr->end()) {
 550                 port_b = x->second;
 551         }
 552
 553         PortConnectedOrDisconnected (
 554                 port_a, jack_port_name (jack_port_a),
 555                 port_b, jack_port_name (jack_port_b),
 556                 conn == 0 ? false : true
 557                 ); /* EMIT SIGNAL */
 558 }
 559
 560 int
 561 JACKAudioBackend::create_process_thread (boost::function<void()> f, pthread_t* thread, size_t stacksize)
 562 {
 563         GET_PRIVATE_JACK_POINTER_RET (_jack, 0);
 564         ThreadData* td = new ThreadData (this, f, stacksize);
 565
 566         if (jack_client_create_thread (_priv_jack, thread, jack_client_real_time_priority (_priv_jack),
 567                                        jack_is_realtime (_priv_jack), _start_process_thread, td)) {
 568                 return -1;
 569         }
 570
 571         return 0;
 572 }
 573
 574 void*
 575 JACKAudioBackend::_start_process_thread (void* arg)
 576 {
 577         ThreadData* td = reinterpret_cast<ThreadData*> (arg);
 578         boost::function<void()> f = td->f;
 579         delete td;
 580
 581         f ();
 582
 583         return 0;
 584 }
 585
 586 void*
 587 JACKAudioBackend::_process_thread (void *arg)
 588 {
 589         return static_cast<AudioEngine *> (arg)->process_thread ();
 590 }
 591
 592 void*
 593 JACKAudioBackend::process_thread ()
 594 {
 595         /* JACK doesn't do this for us when we use the wait API
 596          */
 597
 598         _thread_init_callback (0);
 599
 600         _main_thread = new ProcessThread;
 601
 602         while (1) {
 603                 GET_PRIVATE_JACK_POINTER_RET(_jack,0);
 604
 605                 pframes_t nframes = jack_cycle_wait (_priv_jack);
 606
 607                 if (engine.process_callback (nframes)) {
 608                         return 0;
 609                 }
 610
 611                 jack_cycle_signal (_priv_jack, 0);
 612         }
 613
 614         return 0;
 615 }
 616
 617 int
 618 JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
 619 {
 620         return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
 621 }
 622
 623 int
 624 JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
 625 {
 626         _frame_rate = nframes;
 627         _usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
 628
 629         /* check for monitor input change every 1/10th of second */
 630
 631         monitor_check_interval = nframes / 10;
 632         last_monitor_check = 0;
 633
 634         if (_session) {
 635                 _session->set_frame_rate (nframes);
 636         }
 637
 638         SampleRateChanged (nframes); /* EMIT SIGNAL */
 639
 640         return 0;
 641 }
 642
 643 void
 644 JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
 645 {
 646         if (_session) {
 647                 _session->update_latency (mode == JackPlaybackLatency);
 648         }
 649 }
 650
 651 int
 652 JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
 653 {
 654         return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
 655 }
 656
 657 int
 658 JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
 659 {
 660         /* if the size has not changed, this should be a no-op */
 661
 662         if (nframes == _buffer_size) {
 663                 return 0;
 664         }
 665
 666         GET_PRIVATE_JACK_POINTER_RET (_jack, 1);
 667
 668         _buffer_size = nframes;
 669         _usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
 670         last_monitor_check = 0;
 671
 672         if (jack_port_type_get_buffer_size) {
 673                 _raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
 674                 _raw_buffer_sizes[DataType::MIDI] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_MIDI_TYPE);
 675         } else {
 676
 677                 /* Old version of JACK.
 678
 679                    These crude guesses, see below where we try to get the right answers.
 680
 681                    Note that our guess for MIDI deliberatey tries to overestimate
 682                    by a little. It would be nicer if we could get the actual
 683                    size from a port, but we have to use this estimate in the
 684                    event that there are no MIDI ports currently. If there are
 685                    the value will be adjusted below.
 686                 */
 687
 688                 _raw_buffer_sizes[DataType::AUDIO] = nframes * sizeof (Sample);
 689                 _raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
 690         }
 691
 692         {
 693                 Glib::Threads::Mutex::Lock lm (_process_lock);
 694
 695                 boost::shared_ptr<Ports> p = ports.reader();
 696
 697                 for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
 698                         i->second->reset();
 699                 }
 700         }
 701
 702         if (_session) {
 703                 _session->set_block_size (_buffer_size);
 704         }
 705
 706         return 0;
 707 }
 708
 709 void
 710 JACKAudioBackend::halted_info (jack_status_t code, const char* reason, void *arg)
 711 {
 712         /* called from jack shutdown handler  */
 713
 714         AudioEngine* ae = static_cast<AudioEngine *> (arg);
 715         bool was_running = ae->_running;
 716
 717         ae->stop_metering_thread ();
 718
 719         ae->_running = false;
 720         ae->_buffer_size = 0;
 721         ae->_frame_rate = 0;
 722         ae->_jack = 0;
 723
 724         if (was_running) {
 725                 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
 726 #ifdef HAVE_JACK_ON_INFO_SHUTDOWN
 727                 switch (code) {
 728                 case JackBackendError:
 729                         ae->Halted(reason); /* EMIT SIGNAL */
 730                         break;
 731                 default:
 732                         ae->Halted(""); /* EMIT SIGNAL */
 733                 }
 734 #else
 735                 ae->Halted(""); /* EMIT SIGNAL */
 736 #endif
 737         }
 738 }
 739
 740 void
 741 JACKAudioBackend::halted (void *arg)
 742 {
 743         cerr << "HALTED by JACK\n";
 744
 745         /* called from jack shutdown handler  */
 746
 747         AudioEngine* ae = static_cast<AudioEngine *> (arg);
 748         bool was_running = ae->_running;
 749
 750         ae->stop_metering_thread ();
 751
 752         ae->_running = false;
 753         ae->_buffer_size = 0;
 754         ae->_frame_rate = 0;
 755         ae->_jack = 0;
 756
 757         if (was_running) {
 758                 MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
 759                 ae->Halted(""); /* EMIT SIGNAL */
 760         }
 761 }
 762