00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "JackSystemDeps.h"
00022 #include "JackGraphManager.h"
00023 #include "JackInternalClient.h"
00024 #include "JackServer.h"
00025 #include "JackDebugClient.h"
00026 #include "JackServerGlobals.h"
00027 #include "JackTools.h"
00028 #include "JackCompilerDeps.h"
00029 #include "JackLockedEngine.h"
00030
00031 #ifdef __cplusplus
00032 extern "C"
00033 {
00034 #endif
00035
00036 jack_client_t * jack_client_new_aux (const char *client_name,
00037 jack_options_t options,
00038 jack_status_t *status);
00039 jack_client_t * jack_client_open_aux (const char *client_name,
00040 jack_options_t options,
00041 jack_status_t *status, va_list ap);
00042 EXPORT jack_client_t * jack_client_open (const char *client_name,
00043 jack_options_t options,
00044 jack_status_t *status, ...);
00045 EXPORT int jack_client_close (jack_client_t *client);
00046 EXPORT int jack_get_client_pid (const char *name);
00047
00048 #ifdef __cplusplus
00049 }
00050 #endif
00051
00052 using namespace Jack;
00053
00054 jack_client_t* jack_client_new_aux(const char* client_name, jack_options_t options, jack_status_t* status)
00055 {
00056 jack_varargs_t va;
00057 jack_status_t my_status;
00058 JackClient* client;
00059
00060 if (client_name == NULL) {
00061 jack_error("jack_client_new called with a NULL client_name");
00062 return NULL;
00063 }
00064
00065 jack_log("jack_client_new %s", client_name);
00066
00067 if (status == NULL)
00068 status = &my_status;
00069 *status = (jack_status_t)0;
00070
00071
00072 if ((options & ~JackOpenOptions)) {
00073 int my_status1 = *status | (JackFailure | JackInvalidOption);
00074 *status = (jack_status_t)my_status1;
00075 return NULL;
00076 }
00077
00078
00079 jack_varargs_init(&va);
00080
00081 if (!JackServerGlobals::Init()) {
00082 int my_status1 = (JackFailure | JackServerError);
00083 *status = (jack_status_t)my_status1;
00084 return NULL;
00085 }
00086
00087 if (JACK_DEBUG) {
00088 client = new JackDebugClient(new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable()));
00089 } else {
00090 client = new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable());
00091 }
00092
00093 int res = client->Open(va.server_name, client_name, va.session_id, options, status);
00094 if (res < 0) {
00095 delete client;
00096 JackServerGlobals::Destroy();
00097 int my_status1 = (JackFailure | JackServerError);
00098 *status = (jack_status_t)my_status1;
00099 return NULL;
00100 } else {
00101 return (jack_client_t*)client;
00102 }
00103 }
00104
00105 jack_client_t* jack_client_open_aux(const char* client_name, jack_options_t options, jack_status_t* status, va_list ap)
00106 {
00107 jack_varargs_t va;
00108 jack_status_t my_status;
00109 JackClient* client;
00110
00111 if (client_name == NULL) {
00112 jack_error("jack_client_open called with a NULL client_name");
00113 return NULL;
00114 }
00115
00116 jack_log("jack_client_open %s", client_name);
00117
00118 if (status == NULL)
00119 status = &my_status;
00120 *status = (jack_status_t)0;
00121
00122
00123 if ((options & ~JackOpenOptions)) {
00124 int my_status1 = *status | (JackFailure | JackInvalidOption);
00125 *status = (jack_status_t)my_status1;
00126 return NULL;
00127 }
00128
00129
00130 jack_varargs_parse(options, ap, &va);
00131
00132 if (!JackServerGlobals::Init()) {
00133 int my_status1 = (JackFailure | JackServerError);
00134 *status = (jack_status_t)my_status1;
00135 return NULL;
00136 }
00137
00138 if (JACK_DEBUG) {
00139 client = new JackDebugClient(new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable()));
00140 } else {
00141 client = new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable());
00142 }
00143
00144 int res = client->Open(va.server_name, client_name, va.session_id, options, status);
00145 if (res < 0) {
00146 delete client;
00147 JackServerGlobals::Destroy();
00148 int my_status1 = (JackFailure | JackServerError);
00149 *status = (jack_status_t)my_status1;
00150 return NULL;
00151 } else {
00152 return (jack_client_t*)client;
00153 }
00154 }
00155
00156 EXPORT jack_client_t* jack_client_open(const char* ext_client_name, jack_options_t options, jack_status_t* status, ...)
00157 {
00158 #ifdef __CLIENTDEBUG__
00159 JackGlobals::CheckContext("jack_client_open");
00160 #endif
00161 try {
00162 assert(JackGlobals::fOpenMutex);
00163 JackGlobals::fOpenMutex->Lock();
00164 va_list ap;
00165 va_start(ap, status);
00166 jack_client_t* res = jack_client_open_aux(ext_client_name, options, status, ap);
00167 va_end(ap);
00168 JackGlobals::fOpenMutex->Unlock();
00169 return res;
00170 } catch(std::bad_alloc& e) {
00171 jack_error("Memory allocation error...");
00172 return NULL;
00173 } catch (...) {
00174 jack_error("Unknown error...");
00175 return NULL;
00176 }
00177 }
00178
00179 EXPORT int jack_client_close(jack_client_t* ext_client)
00180 {
00181 #ifdef __CLIENTDEBUG__
00182 JackGlobals::CheckContext("jack_client_close");
00183 #endif
00184 assert(JackGlobals::fOpenMutex);
00185 JackGlobals::fOpenMutex->Lock();
00186 int res = -1;
00187 jack_log("jack_client_close");
00188 JackClient* client = (JackClient*)ext_client;
00189 if (client == NULL) {
00190 jack_error("jack_client_close called with a NULL client");
00191 } else {
00192 res = client->Close();
00193 delete client;
00194 JackServerGlobals::Destroy();
00195 jack_log("jack_client_close res = %d", res);
00196 }
00197 JackGlobals::fOpenMutex->Unlock();
00198 return res;
00199 }
00200
00201 EXPORT int jack_get_client_pid(const char *name)
00202 {
00203 return (JackServerGlobals::fInstance != NULL)
00204 ? JackServerGlobals::fInstance->GetEngine()->GetClientPID(name)
00205 : 0;
00206 }
00207