Jack2
1.9.10
|
00001 /* 00002 Copyright (C) 2004-2008 Grame 00003 00004 This program is free software; you can redistribute it and/or modify 00005 it under the terms of the GNU Lesser General Public License as published by 00006 the Free Software Foundation; either version 2.1 of the License, or 00007 (at your option) any later version. 00008 00009 This program is distributed in the hope that it will be useful, 00010 but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00012 GNU Lesser General Public License for more details. 00013 00014 You should have received a copy of the GNU Lesser General Public License 00015 along with this program; if not, write to the Free Software 00016 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00017 00018 */ 00019 00020 #include "JackDebugClient.h" 00021 #include "JackEngineControl.h" 00022 #include "JackException.h" 00023 #include "JackError.h" 00024 #include "JackTime.h" 00025 #include <iostream> 00026 #include <iomanip> 00027 #include <sstream> 00028 #include <fstream> 00029 #include <string> 00030 #include <time.h> 00031 00032 using namespace std; 00033 00034 namespace Jack 00035 { 00036 00037 JackDebugClient::JackDebugClient(JackClient * client) 00038 { 00039 fTotalPortNumber = 1; // The total number of port opened and maybe closed. Historical view. 00040 fOpenPortNumber = 0; // The current number of opened port. 00041 fIsActivated = 0; 00042 fIsDeactivated = 0; 00043 fIsClosed = 0; 00044 fClient = client; 00045 fFreewheel = false; 00046 } 00047 00048 JackDebugClient::~JackDebugClient() 00049 { 00050 fTotalPortNumber--; // fTotalPortNumber start at 1 00051 *fStream << endl << endl << "----------------------------------- JackDebugClient summary ------------------------------- " << endl << endl; 00052 *fStream << "Client flags ( 1:yes / 0:no ) :" << endl; 00053 *fStream << setw(5) << "- Client call activated : " << fIsActivated << endl; 00054 *fStream << setw(5) << "- Client call deactivated : " << fIsDeactivated << endl; 00055 *fStream << setw(5) << "- Client call closed : " << fIsClosed << endl; 00056 *fStream << setw(5) << "- Total number of instantiated port : " << fTotalPortNumber << endl; 00057 *fStream << setw(5) << "- Number of port remaining open when exiting client : " << fOpenPortNumber << endl; 00058 if (fOpenPortNumber != 0) 00059 *fStream << "!!! WARNING !!! Some ports have not been unregistered ! Incorrect exiting !" << endl; 00060 if (fIsDeactivated != fIsActivated) 00061 *fStream << "!!! ERROR !!! Client seem to not perform symetric activation-deactivation ! (not the same number of activate and deactivate)" << endl; 00062 if (fIsClosed == 0) 00063 *fStream << "!!! ERROR !!! Client have not been closed with jack_client_close() !" << endl; 00064 00065 *fStream << endl << endl << "---------------------------- JackDebugClient detailed port summary ------------------------ " << endl << endl; 00066 //for (int i = 0; i < fTotalPortNumber ; i++) { 00067 for (int i = 1; i <= fTotalPortNumber ; i++) { 00068 *fStream << endl << "Port index (internal debug test value) : " << i << endl; 00069 *fStream << setw(5) << "- Name : " << fPortList[i].name << endl; 00070 *fStream << setw(5) << "- idport : " << fPortList[i].idport << endl; 00071 *fStream << setw(5) << "- IsConnected : " << fPortList[i].IsConnected << endl; 00072 *fStream << setw(5) << "- IsUnregistered : " << fPortList[i].IsUnregistered << endl; 00073 if (fPortList[i].IsUnregistered == 0) 00074 *fStream << "!!! WARNING !!! Port have not been unregistered ! Incorrect exiting !" << endl; 00075 } 00076 *fStream << "delete object JackDebugClient : end of tracing" << endl; 00077 delete fStream; 00078 delete fClient; 00079 } 00080 00081 int JackDebugClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status) 00082 { 00083 int res = fClient->Open(server_name, name, uuid, options, status); 00084 char provstr[256]; 00085 char buffer[256]; 00086 time_t curtime; 00087 struct tm *loctime; 00088 /* Get the current time. */ 00089 curtime = time (NULL); 00090 /* Convert it to local time representation. */ 00091 loctime = localtime (&curtime); 00092 strftime (buffer, 256, "%I-%M", loctime); 00093 snprintf(provstr, sizeof(provstr), "JackClientDebug-%s-%s.log", name, buffer); 00094 fStream = new ofstream(provstr, ios_base::ate); 00095 if (fStream->is_open()) { 00096 if (res == -1) { 00097 *fStream << "Trying to open client with name '" << name << "' with bad result (client not opened)." << res << endl; 00098 } else { 00099 *fStream << "Open client with name '" << name << "'." << endl; 00100 } 00101 } else { 00102 jack_log("JackDebugClient::Open : cannot open log file"); 00103 } 00104 strcpy(fClientName, name); 00105 return res; 00106 } 00107 00108 int JackDebugClient::Close() 00109 { 00110 *fStream << "Client '" << fClientName << "' was closed" << endl; 00111 int res = fClient->Close(); 00112 fIsClosed++; 00113 return res; 00114 } 00115 00116 void JackDebugClient::CheckClient(const char* function_name) const 00117 { 00118 #ifdef WIN32 00119 *fStream << "CheckClient : " << function_name << ", calling thread : " << GetCurrentThread() << endl; 00120 #else 00121 *fStream << "CheckClient : " << function_name << ", calling thread : " << pthread_self() << endl; 00122 #endif 00123 00124 if (fIsClosed > 0) { 00125 *fStream << "!!! ERROR !!! : Accessing a client '" << fClientName << "' already closed " << "from " << function_name << endl; 00126 *fStream << "This is likely to cause crash !'" << endl; 00127 #ifdef __APPLE__ 00128 // Debugger(); 00129 #endif 00130 } 00131 } 00132 00133 jack_native_thread_t JackDebugClient::GetThreadID() 00134 { 00135 CheckClient("GetThreadID"); 00136 return fClient->GetThreadID(); 00137 } 00138 00139 JackGraphManager* JackDebugClient::GetGraphManager() const 00140 { 00141 CheckClient("GetGraphManager"); 00142 return fClient->GetGraphManager(); 00143 } 00144 JackEngineControl* JackDebugClient::GetEngineControl() const 00145 { 00146 CheckClient("GetEngineControl"); 00147 return fClient->GetEngineControl(); 00148 } 00153 int JackDebugClient::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2) 00154 { 00155 CheckClient("ClientNotify"); 00156 return fClient->ClientNotify( refnum, name, notify, sync, message, value1, value2); 00157 } 00158 00159 int JackDebugClient::Activate() 00160 { 00161 CheckClient("Activate"); 00162 int res = fClient->Activate(); 00163 fIsActivated++; 00164 if (fIsDeactivated) 00165 *fStream << "Client '" << fClientName << "' call activate a new time (it already call 'activate' previously)." << endl; 00166 *fStream << "Client '" << fClientName << "' Activated" << endl; 00167 if (res != 0) 00168 *fStream << "Client '" << fClientName << "' try to activate but server return " << res << " ." << endl; 00169 return res; 00170 } 00171 00172 int JackDebugClient::Deactivate() 00173 { 00174 CheckClient("Deactivate"); 00175 int res = fClient->Deactivate(); 00176 fIsDeactivated++; 00177 if (fIsActivated == 0) 00178 *fStream << "Client '" << fClientName << "' deactivate while it hasn't been previoulsy activated !" << endl; 00179 *fStream << "Client '" << fClientName << "' Deactivated" << endl; 00180 if (res != 0) 00181 *fStream << "Client '" << fClientName << "' try to deactivate but server return " << res << " ." << endl; 00182 return res; 00183 } 00184 00185 //----------------- 00186 // Port management 00187 //----------------- 00188 00189 int JackDebugClient::PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size) 00190 { 00191 CheckClient("PortRegister"); 00192 int res = fClient->PortRegister(port_name, port_type, flags, buffer_size); 00193 if (res <= 0) { 00194 *fStream << "Client '" << fClientName << "' try port register ('" << port_name << "') and server return error " << res << " ." << endl; 00195 } else { 00196 if (fTotalPortNumber < MAX_PORT_HISTORY) { 00197 fPortList[fTotalPortNumber].idport = res; 00198 strcpy(fPortList[fTotalPortNumber].name, port_name); 00199 fPortList[fTotalPortNumber].IsConnected = 0; 00200 fPortList[fTotalPortNumber].IsUnregistered = 0; 00201 } else { 00202 *fStream << "!!! WARNING !!! History is full : no more port history will be recorded." << endl; 00203 } 00204 fTotalPortNumber++; 00205 fOpenPortNumber++; 00206 *fStream << "Client '" << fClientName << "' port register with portname '" << port_name << " port " << res << "' ." << endl; 00207 } 00208 return res; 00209 } 00210 00211 int JackDebugClient::PortUnRegister(jack_port_id_t port_index) 00212 { 00213 CheckClient("PortUnRegister"); 00214 int res = fClient->PortUnRegister(port_index); 00215 fOpenPortNumber--; 00216 int i; 00217 for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history 00218 if (fPortList[i].idport == port_index) { // We found the last record 00219 if (fPortList[i].IsUnregistered != 0) 00220 *fStream << "!!! ERROR !!! : '" << fClientName << "' id deregistering port '" << fPortList[i].name << "' that have already been unregistered !" << endl; 00221 fPortList[i].IsUnregistered++; 00222 break; 00223 } 00224 } 00225 if (i == 0) // Port is not found 00226 *fStream << "JackClientDebug : PortUnregister : port " << port_index << " was not previously registered !" << endl; 00227 if (res != 0) 00228 *fStream << "Client '" << fClientName << "' try to do PortUnregister and server return " << res << endl; 00229 *fStream << "Client '" << fClientName << "' unregister port '" << port_index << "'." << endl; 00230 return res; 00231 } 00232 00233 int JackDebugClient::PortConnect(const char* src, const char* dst) 00234 { 00235 CheckClient("PortConnect"); 00236 if (!fIsActivated) 00237 *fStream << "!!! ERROR !!! Trying to connect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl; 00238 int i; 00239 int res = fClient->PortConnect( src, dst); 00240 for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history 00241 if (strcmp(fPortList[i].name, src) == 0) { // We found the last record in sources 00242 if (fPortList[i].IsUnregistered != 0) 00243 *fStream << "!!! ERROR !!! Connecting port " << src << " previoulsy unregistered !" << endl; 00244 fPortList[i].IsConnected++; 00245 *fStream << "Connecting port " << src << " to " << dst << ". "; 00246 break; 00247 } else if (strcmp(fPortList[i].name, dst) == 0 ) { // We found the record in dest 00248 if (fPortList[i].IsUnregistered != 0) 00249 *fStream << "!!! ERROR !!! Connecting port " << dst << " previoulsy unregistered !" << endl; 00250 fPortList[i].IsConnected++; 00251 *fStream << "Connecting port " << src << " to " << dst << ". "; 00252 break; 00253 } 00254 } 00255 if (i == 0) // Port is not found 00256 *fStream << "JackClientDebug : PortConnect : port was not found in debug database !" << endl; 00257 if (res != 0) 00258 *fStream << "Client '" << fClientName << "' try to do PortConnect but server return " << res << " ." << endl; 00259 //*fStream << "Client Port Connect done with names" << endl; 00260 return res; 00261 } 00262 00263 int JackDebugClient::PortDisconnect(const char* src, const char* dst) 00264 { 00265 CheckClient("PortDisconnect"); 00266 if (!fIsActivated) 00267 *fStream << "!!! ERROR !!! Trying to disconnect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl; 00268 int res = fClient->PortDisconnect( src, dst); 00269 int i; 00270 for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history 00271 if (strcmp(fPortList[i].name, src) == 0) { // We found the record in sources 00272 if (fPortList[i].IsUnregistered != 0) 00273 *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl; 00274 fPortList[i].IsConnected--; 00275 *fStream << "disconnecting port " << src << ". "; 00276 break; 00277 } else if (strcmp(fPortList[i].name, dst) == 0 ) { // We found the record in dest 00278 if (fPortList[i].IsUnregistered != 0) 00279 *fStream << "!!! ERROR !!! : Disonnecting port " << dst << " previoulsy unregistered !" << endl; 00280 fPortList[i].IsConnected--; 00281 *fStream << "disconnecting port " << dst << ". "; 00282 break; 00283 } 00284 } 00285 if (i == 0) // Port is not found 00286 *fStream << "JackClientDebug : PortDisConnect : port was not found in debug database !" << endl; 00287 if (res != 0) 00288 *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl; 00289 //*fStream << "Client Port Disconnect done." << endl; 00290 return res; 00291 } 00292 00293 int JackDebugClient::PortDisconnect(jack_port_id_t src) 00294 { 00295 CheckClient("PortDisconnect"); 00296 if (!fIsActivated) 00297 *fStream << "!!! ERROR !!! : Trying to disconnect port " << src << " while that client has not been activated !" << endl; 00298 int res = fClient->PortDisconnect(src); 00299 int i; 00300 for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history 00301 if (fPortList[i].idport == src) { // We found the record in sources 00302 if (fPortList[i].IsUnregistered != 0) 00303 *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl; 00304 fPortList[i].IsConnected--; 00305 *fStream << "Disconnecting port " << src << ". " << endl; 00306 break; 00307 } 00308 } 00309 if (i == 0) // Port is not found 00310 *fStream << "JackClientDebug : PortDisconnect : port was not found in debug database !" << endl; 00311 if (res != 0) 00312 *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl; 00313 //*fStream << "Client Port Disconnect with ID done." << endl; 00314 return res; 00315 } 00316 00317 int JackDebugClient::PortIsMine(jack_port_id_t port_index) 00318 { 00319 CheckClient("PortIsMine"); 00320 *fStream << "JackClientDebug : PortIsMine port_index " << port_index << endl; 00321 return fClient->PortIsMine(port_index); 00322 } 00323 00324 int JackDebugClient::PortRename(jack_port_id_t port_index, const char* name) 00325 { 00326 CheckClient("PortRename"); 00327 *fStream << "JackClientDebug : PortRename port_index " << port_index << "name" << name << endl; 00328 return fClient->PortRename(port_index, name); 00329 } 00330 00331 //-------------------- 00332 // Context management 00333 //-------------------- 00334 00335 int JackDebugClient::SetBufferSize(jack_nframes_t buffer_size) 00336 { 00337 CheckClient("SetBufferSize"); 00338 *fStream << "JackClientDebug : SetBufferSize buffer_size " << buffer_size << endl; 00339 return fClient->SetBufferSize(buffer_size); 00340 } 00341 00342 int JackDebugClient::SetFreeWheel(int onoff) 00343 { 00344 CheckClient("SetFreeWheel"); 00345 if (onoff && fFreewheel) 00346 *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = ON while FW is already ON " << endl; 00347 if (!onoff && !fFreewheel) 00348 *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = OFF while FW is already OFF " << endl; 00349 fFreewheel = onoff ? true : false; 00350 return fClient->SetFreeWheel(onoff); 00351 } 00352 00353 int JackDebugClient::ComputeTotalLatencies() 00354 { 00355 CheckClient("ComputeTotalLatencies"); 00356 return fClient->ComputeTotalLatencies(); 00357 } 00358 00359 /* 00360 ShutDown is called: 00361 - from the RT thread when Execute method fails 00362 - possibly from a "closed" notification channel 00363 (Not needed since the synch object used (Sema of Fifo will fails when server quits... see ShutDown)) 00364 */ 00365 00366 void JackDebugClient::ShutDown(jack_status_t code, const char* message) 00367 { 00368 CheckClient("ShutDown"); 00369 fClient->ShutDown(code, message); 00370 } 00371 00372 //--------------------- 00373 // Transport management 00374 //--------------------- 00375 00376 int JackDebugClient::ReleaseTimebase() 00377 { 00378 CheckClient("ReleaseTimebase"); 00379 return fClient->ReleaseTimebase(); 00380 } 00381 00382 int JackDebugClient::SetSyncCallback(JackSyncCallback sync_callback, void* arg) 00383 { 00384 CheckClient("SetSyncCallback"); 00385 return fClient->SetSyncCallback(sync_callback, arg); 00386 } 00387 00388 int JackDebugClient::SetSyncTimeout(jack_time_t timeout) 00389 { 00390 CheckClient("SetSyncTimeout"); 00391 *fStream << "JackClientDebug : SetSyncTimeout timeout " << timeout << endl; 00392 return fClient->SetSyncTimeout(timeout); 00393 } 00394 00395 int JackDebugClient::SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg) 00396 { 00397 CheckClient("SetTimebaseCallback"); 00398 return fClient->SetTimebaseCallback( conditional, timebase_callback, arg); 00399 } 00400 00401 void JackDebugClient::TransportLocate(jack_nframes_t frame) 00402 { 00403 CheckClient("TransportLocate"); 00404 *fStream << "JackClientDebug : TransportLocate frame " << frame << endl; 00405 fClient->TransportLocate(frame); 00406 } 00407 00408 jack_transport_state_t JackDebugClient::TransportQuery(jack_position_t* pos) 00409 { 00410 CheckClient("TransportQuery"); 00411 return fClient->TransportQuery(pos); 00412 } 00413 00414 jack_nframes_t JackDebugClient::GetCurrentTransportFrame() 00415 { 00416 CheckClient("GetCurrentTransportFrame"); 00417 return fClient->GetCurrentTransportFrame(); 00418 } 00419 00420 int JackDebugClient::TransportReposition(const jack_position_t* pos) 00421 { 00422 CheckClient("TransportReposition"); 00423 return fClient->TransportReposition(pos); 00424 } 00425 00426 void JackDebugClient::TransportStart() 00427 { 00428 CheckClient("TransportStart"); 00429 fClient->TransportStart(); 00430 } 00431 00432 void JackDebugClient::TransportStop() 00433 { 00434 CheckClient("TransportStop"); 00435 fClient->TransportStop(); 00436 } 00437 00438 //--------------------- 00439 // Callback management 00440 //--------------------- 00441 00442 void JackDebugClient::OnShutdown(JackShutdownCallback callback, void *arg) 00443 { 00444 CheckClient("OnShutdown"); 00445 fClient->OnShutdown(callback, arg); 00446 } 00447 00448 void JackDebugClient::OnInfoShutdown(JackInfoShutdownCallback callback, void *arg) 00449 { 00450 CheckClient("OnInfoShutdown"); 00451 fClient->OnInfoShutdown(callback, arg); 00452 } 00453 00454 int JackDebugClient::TimeCallback(jack_nframes_t nframes, void *arg) 00455 { 00456 JackDebugClient* client = (JackDebugClient*)arg; 00457 jack_time_t t1 = GetMicroSeconds(); 00458 int res = client->fProcessTimeCallback(nframes, client->fProcessTimeCallbackArg); 00459 if (res == 0) { 00460 jack_time_t t2 = GetMicroSeconds(); 00461 long delta = long((t2 - t1) - client->GetEngineControl()->fPeriodUsecs); 00462 if (delta > 0 && !client->fFreewheel) { 00463 *client->fStream << "!!! ERROR !!! : Process overload of " << delta << " us" << endl; 00464 } 00465 } 00466 return res; 00467 } 00468 00469 int JackDebugClient::SetProcessCallback(JackProcessCallback callback, void *arg) 00470 { 00471 CheckClient("SetProcessCallback"); 00472 00473 fProcessTimeCallback = callback; 00474 fProcessTimeCallbackArg = arg; 00475 00476 if (callback == NULL) { 00477 // Clear the callback... 00478 return fClient->SetProcessCallback(callback, arg); 00479 } else { 00480 // Setup the measuring version... 00481 return fClient->SetProcessCallback(TimeCallback, this); 00482 } 00483 } 00484 00485 int JackDebugClient::SetXRunCallback(JackXRunCallback callback, void *arg) 00486 { 00487 CheckClient("SetXRunCallback"); 00488 return fClient->SetXRunCallback(callback, arg); 00489 } 00490 00491 int JackDebugClient::SetInitCallback(JackThreadInitCallback callback, void *arg) 00492 { 00493 CheckClient("SetInitCallback"); 00494 return fClient->SetInitCallback(callback, arg); 00495 } 00496 00497 int JackDebugClient::SetGraphOrderCallback(JackGraphOrderCallback callback, void *arg) 00498 { 00499 CheckClient("SetGraphOrderCallback"); 00500 return fClient->SetGraphOrderCallback(callback, arg); 00501 } 00502 00503 int JackDebugClient::SetBufferSizeCallback(JackBufferSizeCallback callback, void *arg) 00504 { 00505 CheckClient("SetBufferSizeCallback"); 00506 return fClient->SetBufferSizeCallback(callback, arg); 00507 } 00508 00509 int JackDebugClient::SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg) 00510 { 00511 CheckClient("SetClientRegistrationCallback"); 00512 return fClient->SetClientRegistrationCallback(callback, arg); 00513 } 00514 00515 int JackDebugClient::SetFreewheelCallback(JackFreewheelCallback callback, void *arg) 00516 { 00517 CheckClient("SetFreewheelCallback"); 00518 return fClient->SetFreewheelCallback(callback, arg); 00519 } 00520 00521 int JackDebugClient::SetPortRegistrationCallback(JackPortRegistrationCallback callback, void *arg) 00522 { 00523 CheckClient("SetPortRegistrationCallback"); 00524 return fClient->SetPortRegistrationCallback(callback, arg); 00525 } 00526 00527 int JackDebugClient::SetPortConnectCallback(JackPortConnectCallback callback, void *arg) 00528 { 00529 CheckClient("SetPortConnectCallback"); 00530 return fClient->SetPortConnectCallback(callback, arg); 00531 } 00532 00533 int JackDebugClient::SetPortRenameCallback(JackPortRenameCallback callback, void *arg) 00534 { 00535 CheckClient("SetPortRenameCallback"); 00536 return fClient->SetPortRenameCallback(callback, arg); 00537 } 00538 00539 int JackDebugClient::SetSessionCallback(JackSessionCallback callback, void *arg) 00540 { 00541 CheckClient("SetSessionCallback"); 00542 return fClient->SetSessionCallback(callback, arg); 00543 } 00544 00545 int JackDebugClient::SetLatencyCallback(JackLatencyCallback callback, void *arg) 00546 { 00547 CheckClient("SetLatencyCallback"); 00548 return fClient->SetLatencyCallback(callback, arg); 00549 } 00550 00551 int JackDebugClient::SetProcessThread(JackThreadCallback fun, void *arg) 00552 { 00553 CheckClient("SetProcessThread"); 00554 return fClient->SetProcessThread(fun, arg); 00555 } 00556 00557 jack_session_command_t* JackDebugClient::SessionNotify(const char* target, jack_session_event_type_t type, const char* path) 00558 { 00559 CheckClient("SessionNotify"); 00560 *fStream << "JackClientDebug : SessionNotify target " << target << "type " << type << "path " << path << endl; 00561 return fClient->SessionNotify(target, type, path); 00562 } 00563 00564 int JackDebugClient::SessionReply(jack_session_event_t* ev) 00565 { 00566 CheckClient("SessionReply"); 00567 return fClient->SessionReply(ev); 00568 } 00569 00570 char* JackDebugClient::GetUUIDForClientName(const char* client_name) 00571 { 00572 CheckClient("GetUUIDForClientName"); 00573 *fStream << "JackClientDebug : GetUUIDForClientName client_name " << client_name << endl; 00574 return fClient->GetUUIDForClientName(client_name); 00575 } 00576 00577 char* JackDebugClient::GetClientNameByUUID(const char* uuid) 00578 { 00579 CheckClient("GetClientNameByUUID"); 00580 *fStream << "JackClientDebug : GetClientNameByUUID uuid " << uuid << endl; 00581 return fClient->GetClientNameByUUID(uuid); 00582 } 00583 00584 int JackDebugClient::ReserveClientName(const char* client_name, const char* uuid) 00585 { 00586 CheckClient("ReserveClientName"); 00587 *fStream << "JackClientDebug : ReserveClientName client_name " << client_name << "uuid " << uuid << endl; 00588 return fClient->ReserveClientName(client_name, uuid); 00589 } 00590 00591 int JackDebugClient::ClientHasSessionCallback(const char* client_name) 00592 { 00593 CheckClient("ClientHasSessionCallback"); 00594 *fStream << "JackClientDebug : ClientHasSessionCallback client_name " << client_name << endl; 00595 return fClient->ClientHasSessionCallback(client_name); 00596 } 00597 00598 JackClientControl* JackDebugClient::GetClientControl() const 00599 { 00600 CheckClient("GetClientControl"); 00601 return fClient->GetClientControl(); 00602 } 00603 00604 // Internal clients 00605 char* JackDebugClient::GetInternalClientName(int ref) 00606 { 00607 CheckClient("GetInternalClientName"); 00608 return fClient->GetInternalClientName(ref); 00609 } 00610 00611 int JackDebugClient::InternalClientHandle(const char* client_name, jack_status_t* status) 00612 { 00613 CheckClient("InternalClientHandle"); 00614 return fClient->InternalClientHandle(client_name, status); 00615 } 00616 00617 int JackDebugClient::InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va) 00618 { 00619 CheckClient("InternalClientLoad"); 00620 return fClient->InternalClientLoad(client_name, options, status, va); 00621 } 00622 00623 void JackDebugClient::InternalClientUnload(int ref, jack_status_t* status) 00624 { 00625 CheckClient("InternalClientUnload"); 00626 fClient->InternalClientUnload(ref, status); 00627 } 00628 00629 } // end of namespace 00630