Jack2 1.9.10

JackDebugClient.cpp

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