00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackDebugClient.h"
00021 #include "JackEngineControl.h"
00022 #include "JackError.h"
00023 #include "JackTime.h"
00024 #include <iostream>
00025 #include <iomanip>
00026 #include <sstream>
00027 #include <fstream>
00028 #include <string>
00029 #include <time.h>
00030
00031 using namespace std;
00032
00033 namespace Jack
00034 {
00035
00036 JackDebugClient::JackDebugClient(JackClient * client)
00037 {
00038 fTotalPortNumber = 1;
00039 fOpenPortNumber = 0;
00040 fIsActivated = 0;
00041 fIsDeactivated = 0;
00042 fIsClosed = 0;
00043 fClient = client;
00044 fFreewheel = false;
00045 }
00046
00047 JackDebugClient::~JackDebugClient()
00048 {
00049 fTotalPortNumber--;
00050 *fStream << endl << endl << "----------------------------------- JackDebugClient summary ------------------------------- " << endl << endl;
00051 *fStream << "Client flags ( 1:yes / 0:no ) :" << endl;
00052 *fStream << setw(5) << "- Client call activated : " << fIsActivated << endl;
00053 *fStream << setw(5) << "- Client call deactivated : " << fIsDeactivated << endl;
00054 *fStream << setw(5) << "- Client call closed : " << fIsClosed << endl;
00055 *fStream << setw(5) << "- Total number of instantiated port : " << fTotalPortNumber << endl;
00056 *fStream << setw(5) << "- Number of port remaining open when exiting client : " << fOpenPortNumber << endl;
00057 if (fOpenPortNumber != 0)
00058 *fStream << "!!! WARNING !!! Some ports have not been unregistrated ! Incorrect exiting !" << endl;
00059 if (fIsDeactivated != fIsActivated)
00060 *fStream << "!!! ERROR !!! Client seem do not perform symetric activation-deactivation ! (not the same number of activate and deactivate)" << endl;
00061 if (fIsClosed == 0)
00062 *fStream << "!!! ERROR !!! Client have not been closed with jack_client_close() !" << endl;
00063
00064 *fStream << endl << endl << "---------------------------- JackDebugClient detailed port summary ------------------------ " << endl << endl;
00065
00066 for (int i = 1; i <= fTotalPortNumber ; i++) {
00067 *fStream << endl << "Port index (internal debug test value) : " << i << endl;
00068 *fStream << setw(5) << "- Name : " << fPortList[i].name << endl;
00069 *fStream << setw(5) << "- idport : " << fPortList[i].idport << endl;
00070 *fStream << setw(5) << "- IsConnected : " << fPortList[i].IsConnected << endl;
00071 *fStream << setw(5) << "- IsUnregistrated : " << fPortList[i].IsUnregistrated << endl;
00072 if (fPortList[i].IsUnregistrated == 0)
00073 *fStream << "!!! WARNING !!! Port have not been unregistrated ! Incorrect exiting !" << endl;
00074 }
00075 *fStream << "delete object JackDebugClient : end of tracing" << endl;
00076 delete fStream;
00077 delete fClient;
00078 }
00079
00080 int JackDebugClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
00081 {
00082 int res = fClient->Open(server_name, name, options, status);
00083 char provstr[256];
00084 char buffer[256];
00085 time_t curtime;
00086 struct tm *loctime;
00087
00088 curtime = time (NULL);
00089
00090 loctime = localtime (&curtime);
00091 strftime (buffer, 256, "%I-%M", loctime);
00092 sprintf(provstr, "JackClientDebug-%s-%s.log", name, buffer);
00093 fStream = new ofstream(provstr, ios_base::ate);
00094 if (fStream->is_open()) {
00095 if (res == -1) {
00096 *fStream << "Trying to open client with name '" << name << "' with bad result (client not opened)." << res << endl;
00097 } else {
00098 *fStream << "Open client with name '" << name << "'." << endl;
00099 }
00100 } else {
00101 jack_log("JackDebugClient::Open : cannot open log file");
00102 }
00103 strcpy(fClientName, name);
00104 return res;
00105 }
00106
00107 int JackDebugClient::Close()
00108 {
00109 fIsClosed++;
00110 *fStream << "Client '" << fClientName << "' was closed" << endl;
00111 return fClient->Close();
00112 }
00113
00114 void JackDebugClient::CheckClient() const
00115 {
00116 if (fIsClosed > 0) {
00117 *fStream << "!!! ERROR !!! : Accessing a client '" << fClientName << "' already closed !" << endl;
00118 *fStream << "This is likely to cause crash !'" << endl;
00119 }
00120 }
00121
00122 pthread_t JackDebugClient::GetThreadID()
00123 {
00124 CheckClient();
00125 return fClient->GetThreadID();
00126 }
00127
00128 JackGraphManager* JackDebugClient::GetGraphManager() const
00129 {
00130 CheckClient();
00131 return fClient->GetGraphManager();
00132 }
00133 JackEngineControl* JackDebugClient::GetEngineControl() const
00134 {
00135 CheckClient();
00136 return fClient->GetEngineControl();
00137 }
00142 int JackDebugClient::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
00143 {
00144 CheckClient();
00145 return fClient->ClientNotify( refnum, name, notify, sync, message, value1, value2);
00146 }
00147
00148 int JackDebugClient::Activate()
00149 {
00150 CheckClient();
00151 int res = fClient->Activate();
00152 fIsActivated++;
00153 if (fIsDeactivated)
00154 *fStream << "Client '" << fClientName << "' call activate a new time (it already call 'activate' previously)." << endl;
00155 *fStream << "Client '" << fClientName << "' Activated" << endl;
00156 if (res != 0)
00157 *fStream << "Client '" << fClientName << "' try to activate but server return " << res << " ." << endl;
00158 return res;
00159 }
00160
00161 int JackDebugClient::Deactivate()
00162 {
00163 CheckClient();
00164 int res = fClient->Deactivate();
00165 fIsDeactivated++;
00166 if (fIsActivated == 0)
00167 *fStream << "Client '" << fClientName << "' deactivate while it hasn't been previoulsy activated !" << endl;
00168 *fStream << "Client '" << fClientName << "' Deactivated" << endl;
00169 if (res != 0)
00170 *fStream << "Client '" << fClientName << "' try to deactivate but server return " << res << " ." << endl;
00171 return res;
00172 }
00173
00174
00175
00176
00177
00178 int JackDebugClient::PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
00179 {
00180 CheckClient();
00181 int res = fClient->PortRegister(port_name, port_type, flags, buffer_size);
00182 if (res <= 0) {
00183 *fStream << "Client '" << fClientName << "' try port register ('" << port_name << "') and server return error " << res << " ." << endl;
00184 } else {
00185 if (fTotalPortNumber < MAX_PORT_HISTORY) {
00186 fPortList[fTotalPortNumber].idport = res;
00187 strcpy(fPortList[fTotalPortNumber].name, port_name);
00188 fPortList[fTotalPortNumber].IsConnected = 0;
00189 fPortList[fTotalPortNumber].IsUnregistrated = 0;
00190 } else {
00191 *fStream << "!!! WARNING !!! History is full : no more port history will be recorded." << endl;
00192 }
00193 fTotalPortNumber++;
00194 fOpenPortNumber++;
00195 *fStream << "Client '" << fClientName << "' port register with portname '" << port_name << " port " << res << "' ." << endl;
00196 }
00197 return res;
00198 }
00199
00200 int JackDebugClient::PortUnRegister(jack_port_id_t port_index)
00201 {
00202 CheckClient();
00203 int res = fClient->PortUnRegister(port_index);
00204 fOpenPortNumber--;
00205 int i;
00206 for (i = (fTotalPortNumber - 1); i >= 0; i--) {
00207 if (fPortList[i].idport == port_index) {
00208 if (fPortList[i].IsUnregistrated != 0)
00209 *fStream << "!!! ERROR !!! : '" << fClientName << "' id deregistering port '" << fPortList[i].name << "' that have already been unregistered !" << endl;
00210 fPortList[i].IsUnregistrated++;
00211 break;
00212 }
00213 }
00214 if (i == 0)
00215 *fStream << "JackClientDebug : PortUnregister : port " << port_index << " was not previously registered !" << endl;
00216 if (res != 0)
00217 *fStream << "Client '" << fClientName << "' try to do PortUnregister and server return " << res << " )." << endl;
00218 *fStream << "Client '" << fClientName << "' unregister port '" << port_index << "'." << endl;
00219 return res;
00220 }
00221
00222 int JackDebugClient::PortConnect(const char* src, const char* dst)
00223 {
00224 CheckClient();
00225 if (!fIsActivated)
00226 *fStream << "!!! ERROR !!! Trying to connect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
00227 int i;
00228 int res = fClient->PortConnect( src, dst);
00229 for (i = (fTotalPortNumber - 1); i >= 0; i--) {
00230 if (strcmp(fPortList[i].name, src) == 0) {
00231 if (fPortList[i].IsUnregistrated != 0)
00232 *fStream << "!!! ERROR !!! Connecting port " << src << " previoulsy unregistered !" << endl;
00233 fPortList[i].IsConnected++;
00234 *fStream << "Connecting port " << src << " to " << dst << ". ";
00235 break;
00236 } else if (strcmp(fPortList[i].name, dst) == 0 ) {
00237 if (fPortList[i].IsUnregistrated != 0)
00238 *fStream << "!!! ERROR !!! Connecting port " << dst << " previoulsy unregistered !" << endl;
00239 fPortList[i].IsConnected++;
00240 *fStream << "Connecting port " << src << " to " << dst << ". ";
00241 break;
00242 }
00243 }
00244 if (i == 0)
00245 *fStream << "JackClientDebug : PortConnect : port was not found in debug database !" << endl;
00246 if (res != 0)
00247 *fStream << "Client '" << fClientName << "' try to do PortConnect but server return " << res << " ." << endl;
00248
00249 return res;
00250 }
00251
00252 int JackDebugClient::PortDisconnect(const char* src, const char* dst)
00253 {
00254 CheckClient();
00255 if (!fIsActivated)
00256 *fStream << "!!! ERROR !!! Trying to disconnect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
00257 int res = fClient->PortDisconnect( src, dst);
00258 int i;
00259 for (i = (fTotalPortNumber - 1); i >= 0; i--) {
00260 if (strcmp(fPortList[i].name, src) == 0) {
00261 if (fPortList[i].IsUnregistrated != 0)
00262 *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl;
00263 fPortList[i].IsConnected--;
00264 *fStream << "disconnecting port " << src << ". ";
00265 break;
00266 } else if (strcmp(fPortList[i].name, dst) == 0 ) {
00267 if (fPortList[i].IsUnregistrated != 0)
00268 *fStream << "!!! ERROR !!! : Disonnecting port " << dst << " previoulsy unregistered !" << endl;
00269 fPortList[i].IsConnected--;
00270 *fStream << "disconnecting port " << dst << ". ";
00271 break;
00272 }
00273 }
00274 if (i == 0)
00275 *fStream << "JackClientDebug : PortDisConnect : port was not found in debug database !" << endl;
00276 if (res != 0)
00277 *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
00278
00279 return res;
00280 }
00281
00282 int JackDebugClient::PortDisconnect(jack_port_id_t src)
00283 {
00284 CheckClient();
00285 if (!fIsActivated)
00286 *fStream << "!!! ERROR !!! : Trying to disconnect port " << src << " while that client has not been activated !" << endl;
00287 int res = fClient->PortDisconnect(src);
00288 int i;
00289 for (i = (fTotalPortNumber - 1); i >= 0; i--) {
00290 if (fPortList[i].idport == src) {
00291 if (fPortList[i].IsUnregistrated != 0)
00292 *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl;
00293 fPortList[i].IsConnected--;
00294 *fStream << "Disconnecting port " << src << ". " << endl;
00295 break;
00296 }
00297 }
00298 if (i == 0)
00299 *fStream << "JackClientDebug : PortDisconnect : port was not found in debug database !" << endl;
00300 if (res != 0)
00301 *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
00302
00303 return res;
00304 }
00305
00306 int JackDebugClient::PortIsMine(jack_port_id_t port_index)
00307 {
00308 CheckClient();
00309 return fClient->PortIsMine(port_index);
00310 }
00311
00312
00313
00314
00315
00316 int JackDebugClient::SetBufferSize(jack_nframes_t buffer_size)
00317 {
00318 CheckClient();
00319 return fClient->SetBufferSize(buffer_size);
00320 }
00321
00322 int JackDebugClient::SetFreeWheel(int onoff)
00323 {
00324 CheckClient();
00325 if (onoff && fFreewheel)
00326 *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = ON while FW is already ON " << endl;
00327 if (!onoff && !fFreewheel)
00328 *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = OFF while FW is already OFF " << endl;
00329 fFreewheel = onoff;
00330 return fClient->SetFreeWheel(onoff);
00331 }
00332
00333
00334
00335
00336
00337
00338
00339
00340 void JackDebugClient::ShutDown()
00341 {
00342 fClient->ShutDown();
00343 }
00344
00345
00346
00347
00348
00349 int JackDebugClient::ReleaseTimebase()
00350 {
00351 CheckClient();
00352 return fClient->ReleaseTimebase();
00353 }
00354
00355 int JackDebugClient::SetSyncCallback(JackSyncCallback sync_callback, void* arg)
00356 {
00357 CheckClient();
00358 return fClient->SetSyncCallback(sync_callback, arg);
00359 }
00360
00361 int JackDebugClient::SetSyncTimeout(jack_time_t timeout)
00362 {
00363 CheckClient();
00364 return fClient->SetSyncTimeout(timeout);
00365 }
00366
00367 int JackDebugClient::SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg)
00368 {
00369 CheckClient();
00370 return fClient->SetTimebaseCallback( conditional, timebase_callback, arg);
00371 }
00372
00373 void JackDebugClient::TransportLocate(jack_nframes_t frame)
00374 {
00375 CheckClient();
00376 fClient->TransportLocate(frame);
00377 }
00378
00379 jack_transport_state_t JackDebugClient::TransportQuery(jack_position_t* pos)
00380 {
00381 CheckClient();
00382 return fClient->TransportQuery(pos);
00383 }
00384
00385 jack_nframes_t JackDebugClient::GetCurrentTransportFrame()
00386 {
00387 CheckClient();
00388 return fClient->GetCurrentTransportFrame();
00389 }
00390
00391 int JackDebugClient::TransportReposition(jack_position_t* pos)
00392 {
00393 CheckClient();
00394 return fClient->TransportReposition(pos);
00395 }
00396
00397 void JackDebugClient::TransportStart()
00398 {
00399 CheckClient();
00400 fClient->TransportStart();
00401 }
00402
00403 void JackDebugClient::TransportStop()
00404 {
00405 CheckClient();
00406 fClient->TransportStop();
00407 }
00408
00409
00410
00411
00412
00413 void JackDebugClient::OnShutdown(JackShutdownCallback callback, void *arg)
00414 {
00415 CheckClient();
00416 fClient->OnShutdown(callback, arg);
00417 }
00418
00419 void JackDebugClient::OnInfoShutdown(JackInfoShutdownCallback callback, void *arg)
00420 {
00421 CheckClient();
00422 fClient->OnInfoShutdown(callback, arg);
00423 }
00424
00425 int JackDebugClient::TimeCallback(jack_nframes_t nframes, void *arg)
00426 {
00427 JackDebugClient* client = (JackDebugClient*)arg;
00428 jack_time_t t1 = GetMicroSeconds();
00429 int res = client->fProcessTimeCallback(nframes, client->fProcessTimeCallbackArg);
00430 jack_time_t t2 = GetMicroSeconds();
00431 long delta = long((t2 - t1) - client->GetEngineControl()->fPeriodUsecs);
00432 if (delta > 0 && !client->fFreewheel)
00433 *client->fStream << "!!! ERROR !!! : Process overload of " << delta << " us" << endl;
00434 return res;
00435 }
00436
00437 int JackDebugClient::SetProcessCallback(JackProcessCallback callback, void *arg)
00438 {
00439 CheckClient();
00440 fProcessTimeCallback = callback;
00441 fProcessTimeCallbackArg = arg;
00442 return fClient->SetProcessCallback(TimeCallback, this);
00443 }
00444
00445 int JackDebugClient::SetXRunCallback(JackXRunCallback callback, void *arg)
00446 {
00447 CheckClient();
00448 return fClient->SetXRunCallback(callback, arg);
00449 }
00450
00451 int JackDebugClient::SetInitCallback(JackThreadInitCallback callback, void *arg)
00452 {
00453 CheckClient();
00454 return fClient->SetInitCallback(callback, arg);
00455 }
00456
00457 int JackDebugClient::SetGraphOrderCallback(JackGraphOrderCallback callback, void *arg)
00458 {
00459 CheckClient();
00460 return fClient->SetGraphOrderCallback(callback, arg);
00461 }
00462
00463 int JackDebugClient::SetBufferSizeCallback(JackBufferSizeCallback callback, void *arg)
00464 {
00465 CheckClient();
00466 return fClient->SetBufferSizeCallback(callback, arg);
00467 }
00468
00469 int JackDebugClient::SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg)
00470 {
00471 CheckClient();
00472 return fClient->SetClientRegistrationCallback(callback, arg);
00473 }
00474
00475 int JackDebugClient::SetFreewheelCallback(JackFreewheelCallback callback, void *arg)
00476 {
00477 CheckClient();
00478 return fClient->SetFreewheelCallback(callback, arg);
00479 }
00480
00481 int JackDebugClient::SetPortRegistrationCallback(JackPortRegistrationCallback callback, void *arg)
00482 {
00483 CheckClient();
00484 return fClient->SetPortRegistrationCallback(callback, arg);
00485 }
00486
00487 int JackDebugClient::SetPortConnectCallback(JackPortConnectCallback callback, void *arg)
00488 {
00489 CheckClient();
00490 return fClient->SetPortConnectCallback(callback, arg);
00491 }
00492
00493 int JackDebugClient::SetPortRenameCallback(JackPortRenameCallback callback, void *arg)
00494 {
00495 CheckClient();
00496 return fClient->SetPortRenameCallback(callback, arg);
00497 }
00498
00499 JackClientControl* JackDebugClient::GetClientControl() const
00500 {
00501 CheckClient();
00502 return fClient->GetClientControl();
00503 }
00504
00505
00506 char* JackDebugClient::GetInternalClientName(int ref)
00507 {
00508 CheckClient();
00509 return fClient->GetInternalClientName(ref);
00510 }
00511
00512 int JackDebugClient::InternalClientHandle(const char* client_name, jack_status_t* status)
00513 {
00514 CheckClient();
00515 return fClient->InternalClientHandle(client_name, status);
00516 }
00517
00518 int JackDebugClient::InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va)
00519 {
00520 CheckClient();
00521 return fClient->InternalClientLoad(client_name, options, status, va);
00522 }
00523
00524 void JackDebugClient::InternalClientUnload(int ref, jack_status_t* status)
00525 {
00526 CheckClient();
00527 fClient->InternalClientUnload(ref, status);
00528 }
00529
00530 }
00531