common/JackDebugClient.cpp

   1 /*
   2 Copyright (C) 2004-2008 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU Lesser General Public License as published by
   6 the Free Software Foundation; either version 2.1 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU Lesser General Public License for more details.
  13
  14 You should have received a copy of the GNU Lesser General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18 */
  19
  20 #include "JackDebugClient.h"
  21 #include "JackEngineControl.h"
  22 #include "JackException.h"
  23 #include "JackError.h"
  24 #include "JackTime.h"
  25 #include <iostream>
  26 #include <iomanip>
  27 #include <sstream>
  28 #include <fstream>
  29 #include <string>
  30 #include <time.h>
  31
  32 using namespace std;
  33
  34 namespace Jack
  35 {
  36
  37 JackDebugClient::JackDebugClient(JackClient * client)
  38 {
  39     fTotalPortNumber = 1;       // The total number of port opened and maybe closed. Historical view.
  40     fOpenPortNumber = 0;        // The current number of opened port.
  41     fIsActivated = 0;
  42     fIsDeactivated = 0;
  43     fIsClosed = 0;
  44     fClient = client;
  45     fFreewheel = false;
  46 }
  47
  48 JackDebugClient::~JackDebugClient()
  49 {
  50     fTotalPortNumber--; // fTotalPortNumber start at 1
  51     *fStream << endl << endl << "----------------------------------- JackDebugClient summary ------------------------------- " << endl << endl;
  52     *fStream << "Client flags ( 1:yes / 0:no ) :" << endl;
  53     *fStream << setw(5) << "- Client call activated : " << fIsActivated << endl;
  54     *fStream << setw(5) << "- Client call deactivated : " << fIsDeactivated << endl;
  55     *fStream << setw(5) << "- Client call closed : " << fIsClosed << endl;
  56     *fStream << setw(5) << "- Total number of instantiated port : " << fTotalPortNumber << endl;
  57     *fStream << setw(5) << "- Number of port remaining open when exiting client : " << fOpenPortNumber << endl;
  58     if (fOpenPortNumber != 0)
  59         *fStream << "!!! WARNING !!! Some ports have not been unregistered ! Incorrect exiting !" << endl;
  60     if (fIsDeactivated != fIsActivated)
  61         *fStream << "!!! ERROR !!! Client seem to not perform symetric activation-deactivation ! (not the same number of activate and deactivate)" << endl;
  62     if (fIsClosed == 0)
  63         *fStream << "!!! ERROR !!! Client have not been closed with jack_client_close() !" << endl;
  64
  65     *fStream << endl << endl << "---------------------------- JackDebugClient detailed port summary ------------------------ " << endl << endl;
  66     //for (int i = 0; i < fTotalPortNumber ; i++) {
  67     for (int i = 1; i <= fTotalPortNumber ; i++) {
  68         *fStream << endl << "Port index (internal debug test value) : " << i << endl;
  69         *fStream << setw(5) << "- Name : " << fPortList[i].name << endl;
  70         *fStream << setw(5) << "- idport : " << fPortList[i].idport << endl;
  71         *fStream << setw(5) << "- IsConnected : " << fPortList[i].IsConnected << endl;
  72         *fStream << setw(5) << "- IsUnregistered : " << fPortList[i].IsUnregistered << endl;
  73         if (fPortList[i].IsUnregistered == 0)
  74             *fStream << "!!! WARNING !!! Port have not been unregistered ! Incorrect exiting !" << endl;
  75     }
  76     *fStream << "delete object JackDebugClient : end of tracing" << endl;
  77     delete fStream;
  78     delete fClient;
  79 }
  80
  81 int JackDebugClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
  82 {
  83     int res = fClient->Open(server_name, name, uuid, options, status);
  84     char provstr[256];
  85     char buffer[256];
  86     time_t curtime;
  87     struct tm *loctime;
  88     /* Get the current time. */
  89     curtime = time (NULL);
  90     /* Convert it to local time representation. */
  91     loctime = localtime (&curtime);
  92     strftime (buffer, 256, "%I-%M", loctime);
  93     snprintf(provstr, sizeof(provstr), "JackClientDebug-%s-%s.log", name, buffer);
  94     fStream = new ofstream(provstr, ios_base::ate);
  95     if (fStream->is_open()) {
  96         if (res == -1) {
  97             *fStream << "Trying to open client with name '" << name << "' with bad result (client not opened)." << res << endl;
  98         } else {
  99             *fStream << "Open client with name '" << name << "'." << endl;
 100         }
 101     } else {
 102         jack_log("JackDebugClient::Open : cannot open log file");
 103     }
 104     strcpy(fClientName, name);
 105     return res;
 106 }
 107
 108 int JackDebugClient::Close()
 109 {
 110     *fStream << "Client '" << fClientName << "' was closed" << endl;
 111     int res = fClient->Close();
 112     fIsClosed++;
 113     return res;
 114 }
 115
 116 void JackDebugClient::CheckClient(const char* function_name) const
 117 {
 118 #ifdef WIN32
 119     *fStream << "CheckClient : " << function_name << ", calling thread : " << GetCurrentThread() << endl;
 120 #else
 121     *fStream << "CheckClient : " << function_name << ", calling thread : " << pthread_self() << endl;
 122 #endif
 123
 124     if (fIsClosed > 0)  {
 125         *fStream << "!!! ERROR !!! : Accessing a client '" << fClientName << "' already closed " << "from " << function_name << endl;
 126         *fStream << "This is likely to cause crash !'" << endl;
 127     #ifdef __APPLE__
 128        // Debugger();
 129     #endif
 130     }
 131 }
 132
 133 jack_native_thread_t JackDebugClient::GetThreadID()
 134 {
 135     CheckClient("GetThreadID");
 136     return fClient->GetThreadID();
 137 }
 138
 139 JackGraphManager* JackDebugClient::GetGraphManager() const
 140 {
 141     CheckClient("GetGraphManager");
 142     return fClient->GetGraphManager();
 143 }
 144 JackEngineControl* JackDebugClient::GetEngineControl() const
 145 {
 146     CheckClient("GetEngineControl");
 147     return fClient->GetEngineControl();
 148 }
 149 /*!
 150 \brief Notification received from the server.
 151 */
 152
 153 int JackDebugClient::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
 154 {
 155     CheckClient("ClientNotify");
 156     return fClient->ClientNotify( refnum, name, notify, sync, message, value1, value2);
 157 }
 158
 159 int JackDebugClient::Activate()
 160 {
 161     CheckClient("Activate");
 162     int res = fClient->Activate();
 163     fIsActivated++;
 164     if (fIsDeactivated)
 165         *fStream << "Client '" << fClientName << "' call activate a new time (it already call 'activate' previously)." << endl;
 166     *fStream << "Client '" << fClientName << "' Activated" << endl;
 167     if (res != 0)
 168         *fStream << "Client '" << fClientName << "' try to activate but server return " << res << " ." << endl;
 169     return res;
 170 }
 171
 172 int JackDebugClient::Deactivate()
 173 {
 174     CheckClient("Deactivate");
 175     int res = fClient->Deactivate();
 176     fIsDeactivated++;
 177     if (fIsActivated == 0)
 178         *fStream << "Client '" << fClientName << "' deactivate while it hasn't been previoulsy activated !" << endl;
 179     *fStream << "Client '" << fClientName << "' Deactivated" << endl;
 180     if (res != 0)
 181         *fStream << "Client '" << fClientName << "' try to deactivate but server return " << res << " ." << endl;
 182     return res;
 183 }
 184
 185 //-----------------
 186 // Port management
 187 //-----------------
 188
 189 int JackDebugClient::PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
 190 {
 191     CheckClient("PortRegister");
 192     int res = fClient->PortRegister(port_name, port_type, flags, buffer_size);
 193     if (res <= 0) {
 194         *fStream << "Client '" << fClientName << "' try port register ('" << port_name << "') and server return error  " << res << " ." << endl;
 195     } else {
 196         if (fTotalPortNumber < MAX_PORT_HISTORY) {
 197             fPortList[fTotalPortNumber].idport = res;
 198             strcpy(fPortList[fTotalPortNumber].name, port_name);
 199             fPortList[fTotalPortNumber].IsConnected = 0;
 200             fPortList[fTotalPortNumber].IsUnregistered = 0;
 201         } else {
 202             *fStream << "!!! WARNING !!! History is full : no more port history will be recorded." << endl;
 203         }
 204         fTotalPortNumber++;
 205         fOpenPortNumber++;
 206         *fStream << "Client '" << fClientName << "' port register with portname '" << port_name << " port " << res << "' ." << endl;
 207     }
 208     return res;
 209 }
 210
 211 int JackDebugClient::PortUnRegister(jack_port_id_t port_index)
 212 {
 213     CheckClient("PortUnRegister");
 214     int res = fClient->PortUnRegister(port_index);
 215     fOpenPortNumber--;
 216     int i;
 217     for (i = (fTotalPortNumber - 1); i >= 0; i--) {     // We search the record into the history
 218         if (fPortList[i].idport == port_index) {                // We found the last record
 219             if (fPortList[i].IsUnregistered != 0)
 220                 *fStream << "!!! ERROR !!! : '" << fClientName << "' id deregistering port '" << fPortList[i].name << "' that have already been unregistered !" << endl;
 221             fPortList[i].IsUnregistered++;
 222             break;
 223         }
 224     }
 225     if (i == 0) // Port is not found
 226         *fStream << "JackClientDebug : PortUnregister : port " << port_index << " was not previously registered !" << endl;
 227     if (res != 0)
 228         *fStream << "Client '" << fClientName << "' try to do PortUnregister and server return " << res << endl;
 229     *fStream << "Client '" << fClientName << "' unregister port '" << port_index << "'." << endl;
 230     return res;
 231 }
 232
 233 int JackDebugClient::PortConnect(const char* src, const char* dst)
 234 {
 235     CheckClient("PortConnect");
 236     if (!fIsActivated)
 237         *fStream << "!!! ERROR !!! Trying to connect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
 238     int i;
 239     int res = fClient->PortConnect( src, dst);
 240     for (i = (fTotalPortNumber - 1); i >= 0; i--) {     // We search the record into the history
 241         if (strcmp(fPortList[i].name, src) == 0) {      // We found the last record in sources
 242             if (fPortList[i].IsUnregistered != 0)
 243                 *fStream << "!!! ERROR !!! Connecting port " << src << " previoulsy unregistered !" << endl;
 244             fPortList[i].IsConnected++;
 245             *fStream << "Connecting port " << src << " to " << dst << ". ";
 246             break;
 247         } else if (strcmp(fPortList[i].name, dst) == 0 ) { // We found the record in dest
 248             if (fPortList[i].IsUnregistered != 0)
 249                 *fStream << "!!! ERROR !!! Connecting port  " << dst << " previoulsy unregistered !" << endl;
 250             fPortList[i].IsConnected++;
 251             *fStream << "Connecting port " << src << " to " << dst << ". ";
 252             break;
 253         }
 254     }
 255     if (i == 0) // Port is not found
 256         *fStream << "JackClientDebug : PortConnect : port was not found in debug database !" << endl;
 257     if (res != 0)
 258         *fStream << "Client '" << fClientName << "' try to do PortConnect but server return " << res << " ." << endl;
 259     //*fStream << "Client Port Connect done with names" << endl;
 260     return res;
 261 }
 262
 263 int JackDebugClient::PortDisconnect(const char* src, const char* dst)
 264 {
 265     CheckClient("PortDisconnect");
 266     if (!fIsActivated)
 267         *fStream << "!!! ERROR !!! Trying to disconnect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
 268     int res = fClient->PortDisconnect( src, dst);
 269     int i;
 270     for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
 271         if (strcmp(fPortList[i].name, src) == 0) { // We found the record in sources
 272             if (fPortList[i].IsUnregistered != 0)
 273                 *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl;
 274             fPortList[i].IsConnected--;
 275             *fStream << "disconnecting port " << src << ". ";
 276             break;
 277         } else if (strcmp(fPortList[i].name, dst) == 0 ) { // We found the record in dest
 278             if (fPortList[i].IsUnregistered != 0)
 279                 *fStream << "!!! ERROR !!! : Disonnecting port  " << dst << " previoulsy unregistered !" << endl;
 280             fPortList[i].IsConnected--;
 281             *fStream << "disconnecting port " << dst << ". ";
 282             break;
 283         }
 284     }
 285     if (i == 0) // Port is not found
 286         *fStream << "JackClientDebug : PortDisConnect : port was not found in debug database !" << endl;
 287     if (res != 0)
 288         *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
 289     //*fStream << "Client Port Disconnect done." << endl;
 290     return res;
 291 }
 292
 293 int JackDebugClient::PortDisconnect(jack_port_id_t src)
 294 {
 295     CheckClient("PortDisconnect");
 296     if (!fIsActivated)
 297         *fStream << "!!! ERROR !!! : Trying to disconnect port " << src << " while that client has not been activated !" << endl;
 298     int res = fClient->PortDisconnect(src);
 299     int i;
 300     for (i = (fTotalPortNumber - 1); i >= 0; i--) {             // We search the record into the history
 301         if (fPortList[i].idport == src) {                               // We found the record in sources
 302             if (fPortList[i].IsUnregistered != 0)
 303                 *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl;
 304             fPortList[i].IsConnected--;
 305             *fStream << "Disconnecting port " << src << ". " << endl;
 306             break;
 307         }
 308     }
 309     if (i == 0) // Port is not found
 310         *fStream << "JackClientDebug : PortDisconnect : port was not found in debug database !" << endl;
 311     if (res != 0)
 312         *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
 313     //*fStream << "Client Port Disconnect with ID done." << endl;
 314     return res;
 315 }
 316
 317 int JackDebugClient::PortIsMine(jack_port_id_t port_index)
 318 {
 319     CheckClient("PortIsMine");
 320     *fStream << "JackClientDebug : PortIsMine port_index " << port_index << endl;
 321     return fClient->PortIsMine(port_index);
 322 }
 323
 324 int JackDebugClient::PortRename(jack_port_id_t port_index, const char* name)
 325 {
 326     CheckClient("PortRename");
 327     *fStream << "JackClientDebug : PortRename port_index " << port_index << "name" << name << endl;
 328     return fClient->PortRename(port_index, name);
 329 }
 330
 331 //--------------------
 332 // Context management
 333 //--------------------
 334
 335 int JackDebugClient::SetBufferSize(jack_nframes_t buffer_size)
 336 {
 337     CheckClient("SetBufferSize");
 338     *fStream << "JackClientDebug : SetBufferSize buffer_size " << buffer_size << endl;
 339     return fClient->SetBufferSize(buffer_size);
 340 }
 341
 342 int JackDebugClient::SetFreeWheel(int onoff)
 343 {
 344     CheckClient("SetFreeWheel");
 345     if (onoff && fFreewheel)
 346         *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = ON while FW is already ON " << endl;
 347     if (!onoff && !fFreewheel)
 348         *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = OFF while FW is already OFF " << endl;
 349     fFreewheel = onoff ? true : false;
 350     return fClient->SetFreeWheel(onoff);
 351 }
 352
 353 int JackDebugClient::ComputeTotalLatencies()
 354 {
 355     CheckClient("ComputeTotalLatencies");
 356     return fClient->ComputeTotalLatencies();
 357 }
 358
 359 /*
 360 ShutDown is called:
 361 - from the RT thread when Execute method fails
 362 - possibly from a "closed" notification channel
 363 (Not needed since the synch object used (Sema of Fifo will fails when server quits... see ShutDown))
 364 */
 365
 366 void JackDebugClient::ShutDown()
 367 {
 368     CheckClient("ShutDown");
 369     fClient->ShutDown();
 370 }
 371
 372 //---------------------
 373 // Transport management
 374 //---------------------
 375
 376 int JackDebugClient::ReleaseTimebase()
 377 {
 378     CheckClient("ReleaseTimebase");
 379     return fClient->ReleaseTimebase();
 380 }
 381
 382 int JackDebugClient::SetSyncCallback(JackSyncCallback sync_callback, void* arg)
 383 {
 384     CheckClient("SetSyncCallback");
 385     return fClient->SetSyncCallback(sync_callback, arg);
 386 }
 387
 388 int JackDebugClient::SetSyncTimeout(jack_time_t timeout)
 389 {
 390     CheckClient("SetSyncTimeout");
 391     *fStream << "JackClientDebug : SetSyncTimeout timeout " << timeout << endl;
 392     return fClient->SetSyncTimeout(timeout);
 393 }
 394
 395 int JackDebugClient::SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg)
 396 {
 397     CheckClient("SetTimebaseCallback");
 398     return fClient->SetTimebaseCallback( conditional, timebase_callback, arg);
 399 }
 400
 401 void JackDebugClient::TransportLocate(jack_nframes_t frame)
 402 {
 403     CheckClient("TransportLocate");
 404     *fStream << "JackClientDebug : TransportLocate frame " << frame << endl;
 405     fClient->TransportLocate(frame);
 406 }
 407
 408 jack_transport_state_t JackDebugClient::TransportQuery(jack_position_t* pos)
 409 {
 410     CheckClient("TransportQuery");
 411     return fClient->TransportQuery(pos);
 412 }
 413
 414 jack_nframes_t JackDebugClient::GetCurrentTransportFrame()
 415 {
 416     CheckClient("GetCurrentTransportFrame");
 417     return fClient->GetCurrentTransportFrame();
 418 }
 419
 420 int JackDebugClient::TransportReposition(jack_position_t* pos)
 421 {
 422     CheckClient("TransportReposition");
 423     return fClient->TransportReposition(pos);
 424 }
 425
 426 void JackDebugClient::TransportStart()
 427 {
 428     CheckClient("TransportStart");
 429     fClient->TransportStart();
 430 }
 431
 432 void JackDebugClient::TransportStop()
 433 {
 434     CheckClient("TransportStop");
 435     fClient->TransportStop();
 436 }
 437
 438 //---------------------
 439 // Callback management
 440 //---------------------
 441
 442 void JackDebugClient::OnShutdown(JackShutdownCallback callback, void *arg)
 443 {
 444     CheckClient("OnShutdown");
 445     fClient->OnShutdown(callback, arg);
 446 }
 447
 448 void JackDebugClient::OnInfoShutdown(JackInfoShutdownCallback callback, void *arg)
 449 {
 450     CheckClient("OnInfoShutdown");
 451     fClient->OnInfoShutdown(callback, arg);
 452 }
 453
 454 int JackDebugClient::TimeCallback(jack_nframes_t nframes, void *arg)
 455 {
 456     JackDebugClient* client = (JackDebugClient*)arg;
 457     jack_time_t t1 = GetMicroSeconds();
 458     int res = client->fProcessTimeCallback(nframes, client->fProcessTimeCallbackArg);
 459     if (res == 0) {
 460         jack_time_t t2 = GetMicroSeconds();
 461         long delta = long((t2 - t1) - client->GetEngineControl()->fPeriodUsecs);
 462         if (delta > 0 && !client->fFreewheel) {
 463             *client->fStream << "!!! ERROR !!! : Process overload of " << delta << " us" << endl;
 464         }
 465     }
 466     return res;
 467 }
 468
 469 int JackDebugClient::SetProcessCallback(JackProcessCallback callback, void *arg)
 470 {
 471     CheckClient("SetProcessCallback");
 472
 473     fProcessTimeCallback = callback;
 474     fProcessTimeCallbackArg = arg;
 475
 476     if (callback == NULL) {
 477         // Clear the callback...
 478         return fClient->SetProcessCallback(callback, arg);
 479     } else {
 480         // Setup the measuring version...
 481         return fClient->SetProcessCallback(TimeCallback, this);
 482     }
 483 }
 484
 485 int JackDebugClient::SetXRunCallback(JackXRunCallback callback, void *arg)
 486 {
 487     CheckClient("SetXRunCallback");
 488     return fClient->SetXRunCallback(callback, arg);
 489 }
 490
 491 int JackDebugClient::SetInitCallback(JackThreadInitCallback callback, void *arg)
 492 {
 493     CheckClient("SetInitCallback");
 494     return fClient->SetInitCallback(callback, arg);
 495 }
 496
 497 int JackDebugClient::SetGraphOrderCallback(JackGraphOrderCallback callback, void *arg)
 498 {
 499     CheckClient("SetGraphOrderCallback");
 500     return fClient->SetGraphOrderCallback(callback, arg);
 501 }
 502
 503 int JackDebugClient::SetBufferSizeCallback(JackBufferSizeCallback callback, void *arg)
 504 {
 505     CheckClient("SetBufferSizeCallback");
 506     return fClient->SetBufferSizeCallback(callback, arg);
 507 }
 508
 509 int JackDebugClient::SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg)
 510 {
 511     CheckClient("SetClientRegistrationCallback");
 512     return fClient->SetClientRegistrationCallback(callback, arg);
 513 }
 514
 515 int JackDebugClient::SetFreewheelCallback(JackFreewheelCallback callback, void *arg)
 516 {
 517     CheckClient("SetFreewheelCallback");
 518     return fClient->SetFreewheelCallback(callback, arg);
 519 }
 520
 521 int JackDebugClient::SetPortRegistrationCallback(JackPortRegistrationCallback callback, void *arg)
 522 {
 523     CheckClient("SetPortRegistrationCallback");
 524     return fClient->SetPortRegistrationCallback(callback, arg);
 525 }
 526
 527 int JackDebugClient::SetPortConnectCallback(JackPortConnectCallback callback, void *arg)
 528 {
 529     CheckClient("SetPortConnectCallback");
 530     return fClient->SetPortConnectCallback(callback, arg);
 531 }
 532
 533 int JackDebugClient::SetPortRenameCallback(JackPortRenameCallback callback, void *arg)
 534 {
 535     CheckClient("SetPortRenameCallback");
 536     return fClient->SetPortRenameCallback(callback, arg);
 537 }
 538
 539 int JackDebugClient::SetSessionCallback(JackSessionCallback callback, void *arg)
 540 {
 541     CheckClient("SetSessionCallback");
 542     return fClient->SetSessionCallback(callback, arg);
 543 }
 544
 545 int JackDebugClient::SetLatencyCallback(JackLatencyCallback callback, void *arg)
 546 {
 547     CheckClient("SetLatencyCallback");
 548     return fClient->SetLatencyCallback(callback, arg);
 549 }
 550
 551 int JackDebugClient::SetProcessThread(JackThreadCallback fun, void *arg)
 552 {
 553     CheckClient("SetProcessThread");
 554     return fClient->SetProcessThread(fun, arg);
 555 }
 556
 557 jack_session_command_t* JackDebugClient::SessionNotify(const char* target, jack_session_event_type_t type, const char* path)
 558 {
 559     CheckClient("SessionNotify");
 560     *fStream << "JackClientDebug : SessionNotify target " << target << "type " << type << "path " << path << endl;
 561     return fClient->SessionNotify(target, type, path);
 562 }
 563
 564 int JackDebugClient::SessionReply(jack_session_event_t* ev)
 565 {
 566     CheckClient("SessionReply");
 567     return fClient->SessionReply(ev);
 568 }
 569
 570 char* JackDebugClient::GetUUIDForClientName(const char* client_name)
 571 {
 572     CheckClient("GetUUIDForClientName");
 573     *fStream << "JackClientDebug : GetUUIDForClientName client_name " << client_name << endl;
 574     return fClient->GetUUIDForClientName(client_name);
 575 }
 576
 577 char* JackDebugClient::GetClientNameByUUID(const char* uuid)
 578 {
 579     CheckClient("GetClientNameByUUID");
 580     *fStream << "JackClientDebug : GetClientNameByUUID uuid " << uuid << endl;
 581     return fClient->GetClientNameByUUID(uuid);
 582 }
 583
 584 int JackDebugClient::ReserveClientName(const char* client_name, const char* uuid)
 585 {
 586     CheckClient("ReserveClientName");
 587     *fStream << "JackClientDebug : ReserveClientName client_name " << client_name << "uuid " << uuid << endl;
 588     return fClient->ReserveClientName(client_name, uuid);
 589 }
 590
 591 int JackDebugClient::ClientHasSessionCallback(const char* client_name)
 592 {
 593     CheckClient("ClientHasSessionCallback");
 594     *fStream << "JackClientDebug : ClientHasSessionCallback client_name " << client_name << endl;
 595     return fClient->ClientHasSessionCallback(client_name);
 596 }
 597
 598 JackClientControl* JackDebugClient::GetClientControl() const
 599 {
 600     CheckClient("GetClientControl");
 601     return fClient->GetClientControl();
 602 }
 603
 604 // Internal clients
 605 char* JackDebugClient::GetInternalClientName(int ref)
 606 {
 607     CheckClient("GetInternalClientName");
 608     return fClient->GetInternalClientName(ref);
 609 }
 610
 611 int JackDebugClient::InternalClientHandle(const char* client_name, jack_status_t* status)
 612 {
 613     CheckClient("InternalClientHandle");
 614     return fClient->InternalClientHandle(client_name, status);
 615 }
 616
 617 int JackDebugClient::InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va)
 618 {
 619     CheckClient("InternalClientLoad");
 620     return fClient->InternalClientLoad(client_name, options, status, va);
 621 }
 622
 623 void JackDebugClient::InternalClientUnload(int ref, jack_status_t* status)
 624 {
 625     CheckClient("InternalClientUnload");
 626     fClient->InternalClientUnload(ref, status);
 627 }
 628
 629 } // end of namespace
 630