Jack2 1.9.10

Jackdmp.cpp

00001 /*
00002 Copyright (C) 2001 Paul Davis
00003 Copyright (C) 2004-2013 Grame
00004 
00005 This program is free software; you can redistribute it and/or modify
00006 it under the terms of the GNU General Public License as published by
00007 the Free Software Foundation; either version 2 of the License, or
00008 (at your option) any later version.
00009 
00010 This program is distributed in the hope that it will be useful,
00011 but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 GNU General Public License for more details.
00014 
00015 You should have received a copy of the GNU General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00018 
00019 */
00020 
00021 #include <iostream>
00022 #include <assert.h>
00023 #include <cassert>
00024 #include <csignal>
00025 #include <sys/types.h>
00026 #include <getopt.h>
00027 #include <cstring>
00028 #include <cstdio>
00029 #include <list>
00030 
00031 #include "types.h"
00032 #include "jack.h"
00033 #include "control.h"
00034 #include "JackConstants.h"
00035 #include "JackPlatformPlug.h"
00036 #ifdef __ANDROID__
00037 #include "JackControlAPIAndroid.h"
00038 #endif
00039 
00040 #if defined(JACK_DBUS) && defined(__linux__)
00041 #include <dbus/dbus.h>
00042 #include "audio_reserve.h"
00043 #endif
00044 
00045 /*
00046 This is a simple port of the old jackdmp.cpp file to use the new jack2 control API. Available options for the server
00047 are "hard-coded" in the source. A much better approach would be to use the control API to:
00048 - dynamically retrieve available server parameters and then prepare to parse them
00049 - get available drivers and their possible parameters, then prepare to parse them.
00050 */
00051 
00052 #ifdef __APPLE__
00053 #include <CoreFoundation/CFNotificationCenter.h>
00054 #include <CoreFoundation/CoreFoundation.h>
00055 
00056 static void notify_server_start(const char* server_name)
00057 {
00058     // Send notification to be used in the JackRouter plugin
00059     CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
00060     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
00061             CFSTR("com.grame.jackserver.start"),
00062             ref,
00063             NULL,
00064             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
00065     CFRelease(ref);
00066 }
00067 
00068 static void notify_server_stop(const char* server_name)
00069 {
00070     // Send notification to be used in the JackRouter plugin
00071     CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
00072     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
00073             CFSTR("com.grame.jackserver.stop"),
00074             ref1,
00075             NULL,
00076             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
00077     CFRelease(ref1);
00078 }
00079 
00080 #else
00081 
00082 static void notify_server_start(const char* server_name)
00083 {}
00084 static void notify_server_stop(const char* server_name)
00085 {}
00086 
00087 #endif
00088 
00089 static void copyright(FILE* file)
00090 {
00091     fprintf(file, "jackdmp " VERSION "\n"
00092             "Copyright 2001-2005 Paul Davis and others.\n"
00093             "Copyright 2004-2014 Grame.\n"
00094             "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
00095             "This is free software, and you are welcome to redistribute it\n"
00096             "under certain conditions; see the file COPYING for details\n");
00097 }
00098 
00099 static jackctl_driver_t * jackctl_server_get_driver(jackctl_server_t *server, const char *driver_name)
00100 {
00101     const JSList * node_ptr = jackctl_server_get_drivers_list(server);
00102 
00103     while (node_ptr) {
00104         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0) {
00105             return (jackctl_driver_t *)node_ptr->data;
00106         }
00107         node_ptr = jack_slist_next(node_ptr);
00108     }
00109 
00110     return NULL;
00111 }
00112 
00113 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
00114 {
00115     const JSList * node_ptr = jackctl_server_get_internals_list(server);
00116 
00117     while (node_ptr) {
00118         if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
00119             return (jackctl_internal_t *)node_ptr->data;
00120         }
00121         node_ptr = jack_slist_next(node_ptr);
00122     }
00123 
00124     return NULL;
00125 }
00126 
00127 static jackctl_parameter_t * jackctl_get_parameter(const JSList * parameters_list, const char * parameter_name)
00128 {
00129     while (parameters_list) {
00130         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0) {
00131             return (jackctl_parameter_t *)parameters_list->data;
00132         }
00133         parameters_list = jack_slist_next(parameters_list);
00134     }
00135 
00136     return NULL;
00137 }
00138 
00139 #ifdef __ANDROID__
00140 static void jackctl_server_switch_master_dummy(jackctl_server_t * server_ctl, char * master_driver_name)
00141 {
00142     static bool is_dummy_driver = false;
00143     if(!strcmp(master_driver_name, "dummy")) {
00144         return;
00145     }
00146     jackctl_driver_t * driver_ctr;
00147     if(is_dummy_driver) {
00148         is_dummy_driver = false;
00149         driver_ctr = jackctl_server_get_driver(server_ctl, master_driver_name);
00150     } else {
00151         is_dummy_driver = true;
00152         driver_ctr = jackctl_server_get_driver(server_ctl, "dummy");
00153     }
00154     jackctl_server_switch_master(server_ctl, driver_ctr);
00155 }
00156 #endif
00157 
00158 static void print_server_drivers(jackctl_server_t *server, FILE* file)
00159 {
00160     const JSList * node_ptr = jackctl_server_get_drivers_list(server);
00161 
00162     fprintf(file, "Available backends:\n");
00163     
00164     while (node_ptr) {
00165         jackctl_driver_t* driver = (jackctl_driver_t *)node_ptr->data;
00166         fprintf(file, "      %s (%s)\n", jackctl_driver_get_name(driver), (jackctl_driver_get_type(driver) == JackMaster) ? "master" : "slave");
00167         node_ptr = jack_slist_next(node_ptr);
00168     }
00169     fprintf(file, "\n");
00170 }
00171 
00172 static void print_server_internals(jackctl_server_t *server, FILE* file)
00173 {
00174     const JSList * node_ptr = jackctl_server_get_internals_list(server);
00175 
00176     fprintf(file, "Available internals:\n");
00177     
00178     while (node_ptr) {
00179         jackctl_internal_t* internal = (jackctl_internal_t *)node_ptr->data;
00180         fprintf(file, "      %s\n", jackctl_internal_get_name(internal));
00181         node_ptr = jack_slist_next(node_ptr);
00182     }
00183     fprintf(file, "\n");
00184 }
00185 
00186 static void usage(FILE* file, jackctl_server_t *server, bool full = true)
00187 {
00188     jackctl_parameter_t * param;
00189     const JSList * server_parameters;
00190     uint32_t i;
00191     union jackctl_parameter_value value;
00192 
00193     fprintf(file, "\n"
00194             "Usage: jackdmp [ --no-realtime OR -r ]\n"
00195             "               [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
00196             "      (the two previous arguments are mutually exclusive. The default is --realtime)\n"
00197             "               [ --name OR -n server-name ]\n"
00198             "               [ --timeout OR -t client-timeout-in-msecs ]\n"
00199             "               [ --loopback OR -L loopback-port-number ]\n"
00200             "               [ --port-max OR -p maximum-number-of-ports]\n"
00201             "               [ --slave-backend OR -X slave-backend-name ]\n"
00202             "               [ --internal-client OR -I internal-client-name ]\n"
00203             "               [ --verbose OR -v ]\n"
00204 #ifdef __linux__
00205             "               [ --clocksource OR -c [ h(pet) | s(ystem) ]\n"
00206 #endif
00207             "               [ --autoconnect OR -a <modechar>]\n");
00208 
00209     server_parameters = jackctl_server_get_parameters(server);
00210     param = jackctl_get_parameter(server_parameters, "self-connect-mode");
00211     fprintf(file,
00212             "                 where <modechar> is one of:\n");
00213     for (i = 0; i < jackctl_parameter_get_enum_constraints_count(param); i++)
00214     {
00215         value = jackctl_parameter_get_enum_constraint_value(param, i);
00216         fprintf(file, "                   '%c' - %s", value.c, jackctl_parameter_get_enum_constraint_description(param, i));
00217         if (value.c == JACK_DEFAULT_SELF_CONNECT_MODE)
00218         {
00219             fprintf(file, " (default)");
00220         }
00221         fprintf(file, "\n");
00222     }
00223 
00224     fprintf(file,
00225             "               [ --replace-registry ]\n"
00226             "               [ --silent OR -s ]\n"
00227             "               [ --sync OR -S ]\n"
00228             "               [ --temporary OR -T ]\n"
00229             "               [ --version OR -V ]\n"
00230             "         -d master-backend-name [ ... master-backend args ... ]\n"
00231             "       jackdmp -d master-backend-name --help\n"
00232             "             to display options for each master backend\n\n");
00233     
00234     if (full) {
00235         print_server_drivers(server, file);
00236         print_server_internals(server, file);
00237     }
00238 }
00239 
00240 // Prototype to be found in libjackserver
00241 extern "C" void silent_jack_error_callback(const char *desc);
00242 
00243 int main(int argc, char** argv)
00244 {
00245     jackctl_server_t * server_ctl;
00246     const JSList * server_parameters;
00247     const char* server_name = JACK_DEFAULT_SERVER_NAME;
00248     jackctl_driver_t * master_driver_ctl;
00249     jackctl_driver_t * loopback_driver_ctl = NULL;
00250     int replace_registry = 0;
00251     const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
00252         "a:"
00253 #ifdef __linux__
00254         "c:"
00255 #endif
00256         ;
00257 
00258     struct option long_options[] = {
00259 #ifdef __linux__
00260                                        { "clock-source", 1, 0, 'c' },
00261 #endif
00262                                        { "loopback-driver", 1, 0, 'L' },
00263                                        { "audio-driver", 1, 0, 'd' },
00264                                        { "midi-driver", 1, 0, 'X' },
00265                                        { "internal-client", 1, 0, 'I' },
00266                                        { "verbose", 0, 0, 'v' },
00267                                        { "help", 0, 0, 'h' },
00268                                        { "port-max", 1, 0, 'p' },
00269                                        { "no-mlock", 0, 0, 'm' },
00270                                        { "name", 1, 0, 'n' },
00271                                        { "unlock", 0, 0, 'u' },
00272                                        { "realtime", 0, 0, 'R' },
00273                                        { "no-realtime", 0, 0, 'r' },
00274                                        { "replace-registry", 0, &replace_registry, 0 },
00275                                        { "loopback", 0, 0, 'L' },
00276                                        { "realtime-priority", 1, 0, 'P' },
00277                                        { "timeout", 1, 0, 't' },
00278                                        { "temporary", 0, 0, 'T' },
00279                                        { "version", 0, 0, 'V' },
00280                                        { "silent", 0, 0, 's' },
00281                                        { "sync", 0, 0, 'S' },
00282                                        { "autoconnect", 1, 0, 'a' },
00283                                        { 0, 0, 0, 0 }
00284                                    };
00285 
00286     int i,opt = 0;
00287     int option_index = 0;
00288     char* master_driver_name = NULL;
00289     char** master_driver_args = NULL;
00290     int master_driver_nargs = 1;
00291     int loopback = 0;
00292     bool show_version = false;
00293     jackctl_sigmask_t * sigmask;
00294     jackctl_parameter_t* param;
00295     union jackctl_parameter_value value;
00296 
00297     std::list<char*> internals_list;
00298     std::list<char*> slaves_list;
00299     std::list<char*>::iterator it;
00300 
00301     // Assume that we fail.
00302     int return_value = -1;
00303     bool notify_sent = false;
00304 
00305     copyright(stdout);
00306 #if defined(JACK_DBUS) && defined(__linux__)
00307     server_ctl = jackctl_server_create(audio_acquire, audio_release);
00308 #else
00309     server_ctl = jackctl_server_create(NULL, NULL);
00310 #endif
00311     if (server_ctl == NULL) {
00312         fprintf(stderr, "Failed to create server object\n");
00313         return -1;
00314     }
00315 
00316     server_parameters = jackctl_server_get_parameters(server_ctl);
00317 
00318     opterr = 0;
00319     while (!master_driver_name &&
00320             (opt = getopt_long(argc, argv, options,
00321                                long_options, &option_index)) != EOF) {
00322         switch (opt) {
00323 
00324         #ifdef __linux__
00325             case 'c':
00326                 param = jackctl_get_parameter(server_parameters, "clock-source");
00327                 if (param != NULL) {
00328                     if (tolower (optarg[0]) == 'h') {
00329                         value.ui = JACK_TIMER_HPET;
00330                         jackctl_parameter_set_value(param, &value);
00331                     } else if (tolower (optarg[0]) == 'c') {
00332                         /* For backwards compatibility with scripts, allow
00333                          * the user to request the cycle clock on the
00334                          * command line, but use the system clock instead
00335                          */
00336                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
00337                         jackctl_parameter_set_value(param, &value);
00338                     } else if (tolower (optarg[0]) == 's') {
00339                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
00340                         jackctl_parameter_set_value(param, &value);
00341                     } else {
00342                         usage(stdout, server_ctl);
00343                         goto destroy_server;
00344                     }
00345                 }
00346                 break;
00347         #endif
00348 
00349             case 'a':
00350                 param = jackctl_get_parameter(server_parameters, "self-connect-mode");
00351                 if (param != NULL) {
00352                     bool value_valid = false;
00353                     for (uint32_t k=0; k<jackctl_parameter_get_enum_constraints_count( param ); k++ ) {
00354                         value = jackctl_parameter_get_enum_constraint_value( param, k );
00355                         if( value.c == optarg[0] )
00356                             value_valid = true;
00357                     }
00358 
00359                     if( value_valid ) {
00360                         value.c = optarg[0];
00361                         jackctl_parameter_set_value(param, &value);
00362                     } else {
00363                         usage(stdout, server_ctl);
00364                         goto destroy_server;
00365                     }
00366                 }
00367                 break;
00368 
00369             case 'd':
00370                 master_driver_name = optarg;
00371                 break;
00372 
00373             case 'L':
00374                 loopback = atoi(optarg);
00375                 break;
00376 
00377             case 'X':
00378                 slaves_list.push_back(optarg);
00379                 break;
00380 
00381             case 'I':
00382                 internals_list.push_back(optarg);
00383                 break;
00384 
00385             case 'p':
00386                 param = jackctl_get_parameter(server_parameters, "port-max");
00387                 if (param != NULL) {
00388                     value.ui = atoi(optarg);
00389                     jackctl_parameter_set_value(param, &value);
00390                 }
00391                 break;
00392 
00393             case 'm':
00394                 break;
00395 
00396             case 'u':
00397                 break;
00398 
00399             case 'v':
00400                 param = jackctl_get_parameter(server_parameters, "verbose");
00401                 if (param != NULL) {
00402                     value.b = true;
00403                     jackctl_parameter_set_value(param, &value);
00404                 }
00405                 break;
00406 
00407             case 's':
00408                 jack_set_error_function(silent_jack_error_callback);
00409                 break;
00410 
00411             case 'S':
00412                 param = jackctl_get_parameter(server_parameters, "sync");
00413                 if (param != NULL) {
00414                     value.b = true;
00415                     jackctl_parameter_set_value(param, &value);
00416                 }
00417                 break;
00418 
00419             case 'n':
00420                 server_name = optarg;
00421                 param = jackctl_get_parameter(server_parameters, "name");
00422                 if (param != NULL) {
00423                     strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
00424                     jackctl_parameter_set_value(param, &value);
00425                 }
00426                 break;
00427 
00428             case 'P':
00429                 param = jackctl_get_parameter(server_parameters, "realtime-priority");
00430                 if (param != NULL) {
00431                     value.i = atoi(optarg);
00432                     jackctl_parameter_set_value(param, &value);
00433                 }
00434                 break;
00435 
00436             case 'r':
00437                 param = jackctl_get_parameter(server_parameters, "realtime");
00438                 if (param != NULL) {
00439                     value.b = false;
00440                     jackctl_parameter_set_value(param, &value);
00441                 }
00442                 break;
00443 
00444             case 'R':
00445                 param = jackctl_get_parameter(server_parameters, "realtime");
00446                 if (param != NULL) {
00447                     value.b = true;
00448                     jackctl_parameter_set_value(param, &value);
00449                 }
00450                 break;
00451 
00452             case 'T':
00453                 param = jackctl_get_parameter(server_parameters, "temporary");
00454                 if (param != NULL) {
00455                     value.b = true;
00456                     jackctl_parameter_set_value(param, &value);
00457                 }
00458                 break;
00459 
00460             case 't':
00461                 param = jackctl_get_parameter(server_parameters, "client-timeout");
00462                 if (param != NULL) {
00463                     value.i = atoi(optarg);
00464                     jackctl_parameter_set_value(param, &value);
00465                 }
00466                 break;
00467 
00468             case 'V':
00469                 show_version = true;
00470                 break;
00471 
00472             default:
00473                 fprintf(stderr, "unknown option character %c\n", optopt);
00474                 /*fallthru*/
00475 
00476             case 'h':
00477                 usage(stdout, server_ctl);
00478                 goto destroy_server;
00479         }
00480     }
00481 
00482     // Long option with no letter so treated separately
00483     param = jackctl_get_parameter(server_parameters, "replace-registry");
00484     if (param != NULL) {
00485         value.b = replace_registry;
00486         jackctl_parameter_set_value(param, &value);
00487     }
00488 
00489     if (show_version) {
00490         printf( "jackdmp version " VERSION
00491                 " tmpdir " jack_server_dir
00492                 " protocol %d"
00493                 "\n", JACK_PROTOCOL_VERSION);
00494         return -1;
00495     }
00496 
00497     if (!master_driver_name) {
00498         usage(stderr, server_ctl, false);
00499         goto destroy_server;
00500     }
00501 
00502     // Master driver
00503     master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
00504     if (master_driver_ctl == NULL) {
00505         fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
00506         goto destroy_server;
00507     }
00508 
00509     if (jackctl_driver_get_type(master_driver_ctl) != JackMaster) {
00510         fprintf(stderr, "Driver \"%s\" is not a master \n", master_driver_name);
00511         goto destroy_server;
00512     }
00513 
00514     if (optind < argc) {
00515         master_driver_nargs = 1 + argc - optind;
00516     } else {
00517         master_driver_nargs = 1;
00518     }
00519 
00520     if (master_driver_nargs == 0) {
00521         fprintf(stderr, "No driver specified ... hmm. JACK won't do"
00522                 " anything when run like this.\n");
00523         goto destroy_server;
00524     }
00525 
00526     master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
00527     master_driver_args[0] = master_driver_name;
00528 
00529     for (i = 1; i < master_driver_nargs; i++) {
00530         master_driver_args[i] = argv[optind++];
00531     }
00532 
00533     if (jackctl_driver_params_parse(master_driver_ctl, master_driver_nargs, master_driver_args)) {
00534         goto destroy_server;
00535     }
00536 
00537     // Setup signals
00538     sigmask = jackctl_setup_signals(0);
00539 
00540     // Open server
00541     if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
00542         fprintf(stderr, "Failed to open server\n");
00543         goto destroy_server;
00544     }
00545 
00546     // Slave drivers
00547     for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
00548         jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
00549         if (slave_driver_ctl == NULL) {
00550             fprintf(stderr, "Unknown driver \"%s\"\n", *it);
00551             goto close_server;
00552         }
00553         if (jackctl_driver_get_type(slave_driver_ctl) != JackSlave) {
00554             fprintf(stderr, "Driver \"%s\" is not a slave \n", *it);
00555             goto close_server;
00556         }
00557         if (!jackctl_server_add_slave(server_ctl, slave_driver_ctl)) {
00558             fprintf(stderr, "Driver \"%s\" cannot be loaded\n", *it);
00559             goto close_server;
00560         }
00561     }
00562 
00563     // Loopback driver
00564     if (loopback > 0) {
00565         loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
00566 
00567         if (loopback_driver_ctl != NULL) {
00568             const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
00569             param = jackctl_get_parameter(loopback_parameters, "channels");
00570             if (param != NULL) {
00571                 value.ui = loopback;
00572                 jackctl_parameter_set_value(param, &value);
00573             }
00574             if (!jackctl_server_add_slave(server_ctl, loopback_driver_ctl)) {
00575                 fprintf(stderr, "Driver \"loopback\" cannot be loaded\n");
00576                 goto close_server;
00577             }
00578         } else {
00579             fprintf(stderr, "Driver \"loopback\" not found\n");
00580             goto close_server;
00581         }
00582     }
00583 
00584     // Start the server
00585     if (!jackctl_server_start(server_ctl)) {
00586         fprintf(stderr, "Failed to start server\n");
00587         goto close_server;
00588     }
00589 
00590     // Internal clients
00591     for (it = internals_list.begin(); it != internals_list.end(); it++) {
00592         jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
00593         if (internal_driver_ctl == NULL) {
00594             fprintf(stderr, "Unknown internal \"%s\"\n", *it);
00595             goto stop_server;
00596         }
00597         if (!jackctl_server_load_internal(server_ctl, internal_driver_ctl)) {
00598             fprintf(stderr, "Internal client \"%s\" cannot be loaded\n", *it);
00599             goto stop_server;
00600         }
00601     }
00602 
00603     notify_server_start(server_name);
00604     notify_sent = true;
00605     return_value = 0;
00606 
00607     // Waits for signal
00608 #ifdef __ANDROID__
00609     //reserve SIGUSR2 signal for switching master driver
00610     while(1) {
00611         int signal = jackctl_wait_signals_and_return(sigmask);
00612         if (signal == SIGUSR2) {
00613             jackctl_server_switch_master_dummy(server_ctl, master_driver_name);
00614         } else {
00615             break;
00616         }
00617     }
00618 #else
00619     jackctl_wait_signals(sigmask);
00620 #endif
00621 
00622  stop_server:
00623     if (!jackctl_server_stop(server_ctl)) {
00624         fprintf(stderr, "Cannot stop server...\n");
00625     }
00626 
00627  close_server:
00628     if (loopback > 0 && loopback_driver_ctl) {
00629         jackctl_server_remove_slave(server_ctl, loopback_driver_ctl);
00630     }
00631     // Slave drivers
00632     for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
00633         jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
00634         if (slave_driver_ctl) {
00635             jackctl_server_remove_slave(server_ctl, slave_driver_ctl);
00636         }
00637     }
00638 
00639     // Internal clients
00640     for (it = internals_list.begin(); it != internals_list.end(); it++) {
00641         jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
00642         if (internal_driver_ctl) {
00643             jackctl_server_unload_internal(server_ctl, internal_driver_ctl);
00644         }
00645     }
00646     jackctl_server_close(server_ctl);
00647 
00648  destroy_server:
00649     jackctl_server_destroy(server_ctl);
00650     if (notify_sent) {
00651         notify_server_stop(server_name);
00652     }
00653     return return_value;
00654 }