JackDebugClient.cpp 20.8 KB
Newer Older
sletz's avatar
sletz committed
1
/*
sletz's avatar
sletz committed
2
Copyright (C) 2004-2008 Grame
sletz's avatar
sletz committed
3
4

This program is free software; you can redistribute it and/or modify
sletz's avatar
sletz committed
5
6
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
sletz's avatar
sletz committed
7
8
9
10
11
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
sletz's avatar
sletz committed
12
GNU Lesser General Public License for more details.
sletz's avatar
sletz committed
13

sletz's avatar
sletz committed
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
sletz's avatar
sletz committed
16
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
sletz's avatar
sletz committed
17
18
19
20

*/

#include "JackDebugClient.h"
21
#include "JackEngineControl.h"
sletz's avatar
sletz committed
22
#include "JackException.h"
sletz's avatar
sletz committed
23
#include "JackError.h"
24
#include "JackTime.h"
sletz's avatar
sletz committed
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <string>
#include <time.h>

using namespace std;

namespace Jack
{

JackDebugClient::JackDebugClient(JackClient * client)
{
39
40
    fTotalPortNumber = 1;       // The total number of port opened and maybe closed. Historical view.
    fOpenPortNumber = 0;        // The current number of opened port.
sletz's avatar
sletz committed
41
42
43
44
    fIsActivated = 0;
    fIsDeactivated = 0;
    fIsClosed = 0;
    fClient = client;
45
    fFreewheel = false;
sletz's avatar
sletz committed
46
47
48
49
50
51
52
53
54
55
56
57
58
}

JackDebugClient::~JackDebugClient()
{
    fTotalPortNumber--; // fTotalPortNumber start at 1
    *fStream << endl << endl << "----------------------------------- JackDebugClient summary ------------------------------- " << endl << endl;
    *fStream << "Client flags ( 1:yes / 0:no ) :" << endl;
    *fStream << setw(5) << "- Client call activated : " << fIsActivated << endl;
    *fStream << setw(5) << "- Client call deactivated : " << fIsDeactivated << endl;
    *fStream << setw(5) << "- Client call closed : " << fIsClosed << endl;
    *fStream << setw(5) << "- Total number of instantiated port : " << fTotalPortNumber << endl;
    *fStream << setw(5) << "- Number of port remaining open when exiting client : " << fOpenPortNumber << endl;
    if (fOpenPortNumber != 0)
sletz's avatar
sletz committed
59
        *fStream << "!!! WARNING !!! Some ports have not been unregistered ! Incorrect exiting !" << endl;
sletz's avatar
sletz committed
60
    if (fIsDeactivated != fIsActivated)
sletz's avatar
sletz committed
61
        *fStream << "!!! ERROR !!! Client seem to not perform symetric activation-deactivation ! (not the same number of activate and deactivate)" << endl;
sletz's avatar
sletz committed
62
63
64
65
66
67
68
69
70
71
    if (fIsClosed == 0)
        *fStream << "!!! ERROR !!! Client have not been closed with jack_client_close() !" << endl;

    *fStream << endl << endl << "---------------------------- JackDebugClient detailed port summary ------------------------ " << endl << endl;
    //for (int i = 0; i < fTotalPortNumber ; i++) {
    for (int i = 1; i <= fTotalPortNumber ; i++) {
        *fStream << endl << "Port index (internal debug test value) : " << i << endl;
        *fStream << setw(5) << "- Name : " << fPortList[i].name << endl;
        *fStream << setw(5) << "- idport : " << fPortList[i].idport << endl;
        *fStream << setw(5) << "- IsConnected : " << fPortList[i].IsConnected << endl;
sletz's avatar
sletz committed
72
73
74
        *fStream << setw(5) << "- IsUnregistered : " << fPortList[i].IsUnregistered << endl;
        if (fPortList[i].IsUnregistered == 0)
            *fStream << "!!! WARNING !!! Port have not been unregistered ! Incorrect exiting !" << endl;
sletz's avatar
sletz committed
75
76
77
78
79
80
    }
    *fStream << "delete object JackDebugClient : end of tracing" << endl;
    delete fStream;
    delete fClient;
}

Stéphane LETZ's avatar
Stéphane LETZ committed
81
int JackDebugClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
sletz's avatar
sletz committed
82
{
Stéphane LETZ's avatar
Stéphane LETZ committed
83
    int res = fClient->Open(server_name, name, uuid, options, status);
sletz's avatar
sletz committed
84
85
86
87
88
89
90
91
92
93
94
95
    char provstr[256];
    char buffer[256];
    time_t curtime;
    struct tm *loctime;
    /* Get the current time. */
    curtime = time (NULL);
    /* Convert it to local time representation. */
    loctime = localtime (&curtime);
    strftime (buffer, 256, "%I-%M", loctime);
    sprintf(provstr, "JackClientDebug-%s-%s.log", name, buffer);
    fStream = new ofstream(provstr, ios_base::ate);
    if (fStream->is_open()) {
96
97
        if (res == -1) {
            *fStream << "Trying to open client with name '" << name << "' with bad result (client not opened)." << res << endl;
sletz's avatar
sletz committed
98
        } else {
99
            *fStream << "Open client with name '" << name << "'." << endl;
sletz's avatar
sletz committed
100
101
        }
    } else {
sletz's avatar
sletz committed
102
        jack_log("JackDebugClient::Open : cannot open log file");
sletz's avatar
sletz committed
103
104
    }
    strcpy(fClientName, name);
105
    return res;
sletz's avatar
sletz committed
106
107
108
109
}

int JackDebugClient::Close()
{
110
    *fStream << "Client '" << fClientName << "' was closed" << endl;
sletz's avatar
sletz committed
111
112
113
    int res = fClient->Close();
    fIsClosed++;
    return res;
sletz's avatar
sletz committed
114
115
}

sletz's avatar
sletz committed
116
void JackDebugClient::CheckClient(const char* function_name) const
117
{
sletz's avatar
sletz committed
118
    *fStream << "CheckClient : " << function_name << ", calling thread : " << pthread_self() << endl;
119

120
    if (fIsClosed > 0)  {
121
        *fStream << "!!! ERROR !!! : Accessing a client '" << fClientName << "' already closed " << "from " << function_name << endl;
sletz's avatar
sletz committed
122
        *fStream << "This is likely to cause crash !'" << endl;
sletz's avatar
sletz committed
123
    #ifdef __APPLE__
sletz's avatar
sletz committed
124
       // Debugger();
125
    #endif
sletz's avatar
sletz committed
126
    }
127
128
}

129
jack_native_thread_t JackDebugClient::GetThreadID()
sletz's avatar
sletz committed
130
{
sletz's avatar
sletz committed
131
    CheckClient("GetThreadID");
sletz's avatar
sletz committed
132
133
134
135
136
    return fClient->GetThreadID();
}

JackGraphManager* JackDebugClient::GetGraphManager() const
{
sletz's avatar
sletz committed
137
    CheckClient("GetGraphManager");
sletz's avatar
sletz committed
138
139
140
141
    return fClient->GetGraphManager();
}
JackEngineControl* JackDebugClient::GetEngineControl() const
{
sletz's avatar
sletz committed
142
    CheckClient("GetEngineControl");
sletz's avatar
sletz committed
143
144
145
146
147
148
    return fClient->GetEngineControl();
}
/*!
\brief Notification received from the server.
*/

149
int JackDebugClient::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
sletz's avatar
sletz committed
150
{
sletz's avatar
sletz committed
151
    CheckClient("ClientNotify");
152
    return fClient->ClientNotify( refnum, name, notify, sync, message, value1, value2);
sletz's avatar
sletz committed
153
154
155
156
}

int JackDebugClient::Activate()
{
sletz's avatar
sletz committed
157
    CheckClient("Activate");
sletz's avatar
Cleanup    
sletz committed
158
    int res = fClient->Activate();
sletz's avatar
sletz committed
159
160
161
162
    fIsActivated++;
    if (fIsDeactivated)
        *fStream << "Client '" << fClientName << "' call activate a new time (it already call 'activate' previously)." << endl;
    *fStream << "Client '" << fClientName << "' Activated" << endl;
163
164
165
    if (res != 0)
        *fStream << "Client '" << fClientName << "' try to activate but server return " << res << " ." << endl;
    return res;
sletz's avatar
sletz committed
166
167
168
169
}

int JackDebugClient::Deactivate()
{
sletz's avatar
sletz committed
170
    CheckClient("Deactivate");
sletz's avatar
Cleanup    
sletz committed
171
    int res = fClient->Deactivate();
sletz's avatar
sletz committed
172
173
174
175
    fIsDeactivated++;
    if (fIsActivated == 0)
        *fStream << "Client '" << fClientName << "' deactivate while it hasn't been previoulsy activated !" << endl;
    *fStream << "Client '" << fClientName << "' Deactivated" << endl;
176
177
178
    if (res != 0)
        *fStream << "Client '" << fClientName << "' try to deactivate but server return " << res << " ." << endl;
    return res;
sletz's avatar
sletz committed
179
180
181
182
183
184
185
186
}

//-----------------
// Port management
//-----------------

int JackDebugClient::PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
{
sletz's avatar
sletz committed
187
    CheckClient("PortRegister");
sletz's avatar
Cleanup    
sletz committed
188
    int res = fClient->PortRegister(port_name, port_type, flags, buffer_size);
189
190
    if (res <= 0) {
        *fStream << "Client '" << fClientName << "' try port register ('" << port_name << "') and server return error  " << res << " ." << endl;
sletz's avatar
sletz committed
191
192
    } else {
        if (fTotalPortNumber < MAX_PORT_HISTORY) {
193
            fPortList[fTotalPortNumber].idport = res;
sletz's avatar
sletz committed
194
195
            strcpy(fPortList[fTotalPortNumber].name, port_name);
            fPortList[fTotalPortNumber].IsConnected = 0;
sletz's avatar
sletz committed
196
            fPortList[fTotalPortNumber].IsUnregistered = 0;
sletz's avatar
sletz committed
197
198
199
200
201
        } else {
            *fStream << "!!! WARNING !!! History is full : no more port history will be recorded." << endl;
        }
        fTotalPortNumber++;
        fOpenPortNumber++;
202
        *fStream << "Client '" << fClientName << "' port register with portname '" << port_name << " port " << res << "' ." << endl;
sletz's avatar
sletz committed
203
    }
204
    return res;
sletz's avatar
sletz committed
205
206
207
208
}

int JackDebugClient::PortUnRegister(jack_port_id_t port_index)
{
sletz's avatar
sletz committed
209
    CheckClient("PortUnRegister");
sletz's avatar
Cleanup    
sletz committed
210
    int res = fClient->PortUnRegister(port_index);
sletz's avatar
sletz committed
211
212
    fOpenPortNumber--;
    int i;
213
214
    for (i = (fTotalPortNumber - 1); i >= 0; i--) {     // We search the record into the history
        if (fPortList[i].idport == port_index) {                // We found the last record
sletz's avatar
sletz committed
215
            if (fPortList[i].IsUnregistered != 0)
sletz's avatar
sletz committed
216
                *fStream << "!!! ERROR !!! : '" << fClientName << "' id deregistering port '" << fPortList[i].name << "' that have already been unregistered !" << endl;
sletz's avatar
sletz committed
217
            fPortList[i].IsUnregistered++;
sletz's avatar
sletz committed
218
219
220
221
222
            break;
        }
    }
    if (i == 0) // Port is not found
        *fStream << "JackClientDebug : PortUnregister : port " << port_index << " was not previously registered !" << endl;
223
    if (res != 0)
sletz's avatar
sletz committed
224
        *fStream << "Client '" << fClientName << "' try to do PortUnregister and server return " << res << endl;
sletz's avatar
sletz committed
225
    *fStream << "Client '" << fClientName << "' unregister port '" << port_index << "'." << endl;
226
    return res;
sletz's avatar
sletz committed
227
228
229
230
}

int JackDebugClient::PortConnect(const char* src, const char* dst)
{
sletz's avatar
sletz committed
231
    CheckClient("PortConnect");
232
    if (!fIsActivated)
sletz's avatar
sletz committed
233
234
        *fStream << "!!! ERROR !!! Trying to connect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
    int i;
sletz's avatar
Cleanup    
sletz committed
235
    int res = fClient->PortConnect( src, dst);
236
237
    for (i = (fTotalPortNumber - 1); i >= 0; i--) {     // We search the record into the history
        if (strcmp(fPortList[i].name, src) == 0) {      // We found the last record in sources
sletz's avatar
sletz committed
238
            if (fPortList[i].IsUnregistered != 0)
sletz's avatar
sletz committed
239
240
241
242
243
                *fStream << "!!! ERROR !!! Connecting port " << src << " previoulsy unregistered !" << endl;
            fPortList[i].IsConnected++;
            *fStream << "Connecting port " << src << " to " << dst << ". ";
            break;
        } else if (strcmp(fPortList[i].name, dst) == 0 ) { // We found the record in dest
sletz's avatar
sletz committed
244
            if (fPortList[i].IsUnregistered != 0)
sletz's avatar
sletz committed
245
246
247
248
249
250
251
252
                *fStream << "!!! ERROR !!! Connecting port  " << dst << " previoulsy unregistered !" << endl;
            fPortList[i].IsConnected++;
            *fStream << "Connecting port " << src << " to " << dst << ". ";
            break;
        }
    }
    if (i == 0) // Port is not found
        *fStream << "JackClientDebug : PortConnect : port was not found in debug database !" << endl;
253
254
    if (res != 0)
        *fStream << "Client '" << fClientName << "' try to do PortConnect but server return " << res << " ." << endl;
sletz's avatar
sletz committed
255
    //*fStream << "Client Port Connect done with names" << endl;
256
    return res;
sletz's avatar
sletz committed
257
258
259
260
}

int JackDebugClient::PortDisconnect(const char* src, const char* dst)
{
sletz's avatar
sletz committed
261
    CheckClient("PortDisconnect");
262
    if (!fIsActivated)
sletz's avatar
sletz committed
263
        *fStream << "!!! ERROR !!! Trying to disconnect a port ( " << src << " to " << dst << ") while the client has not been activated !" << endl;
sletz's avatar
Cleanup    
sletz committed
264
    int res = fClient->PortDisconnect( src, dst);
sletz's avatar
sletz committed
265
266
267
    int i;
    for (i = (fTotalPortNumber - 1); i >= 0; i--) { // We search the record into the history
        if (strcmp(fPortList[i].name, src) == 0) { // We found the record in sources
sletz's avatar
sletz committed
268
            if (fPortList[i].IsUnregistered != 0)
sletz's avatar
sletz committed
269
270
271
272
273
                *fStream << "!!! ERROR !!! : Disconnecting port " << src << " previoulsy unregistered !" << endl;
            fPortList[i].IsConnected--;
            *fStream << "disconnecting port " << src << ". ";
            break;
        } else if (strcmp(fPortList[i].name, dst) == 0 ) { // We found the record in dest
sletz's avatar
sletz committed
274
            if (fPortList[i].IsUnregistered != 0)
sletz's avatar
sletz committed
275
276
277
278
279
280
281
282
                *fStream << "!!! ERROR !!! : Disonnecting port  " << dst << " previoulsy unregistered !" << endl;
            fPortList[i].IsConnected--;
            *fStream << "disconnecting port " << dst << ". ";
            break;
        }
    }
    if (i == 0) // Port is not found
        *fStream << "JackClientDebug : PortDisConnect : port was not found in debug database !" << endl;
283
284
    if (res != 0)
        *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
sletz's avatar
sletz committed
285
    //*fStream << "Client Port Disconnect done." << endl;
286
    return res;
sletz's avatar
sletz committed
287
288
289
290
}

int JackDebugClient::PortDisconnect(jack_port_id_t src)
{
sletz's avatar
sletz committed
291
    CheckClient("PortDisconnect");
292
    if (!fIsActivated)
sletz's avatar
sletz committed
293
        *fStream << "!!! ERROR !!! : Trying to disconnect port  " << src << " while that client has not been activated !" << endl;
sletz's avatar
Cleanup    
sletz committed
294
    int res = fClient->PortDisconnect(src);
sletz's avatar
sletz committed
295
    int i;
296
297
    for (i = (fTotalPortNumber - 1); i >= 0; i--) {             // We search the record into the history
        if (fPortList[i].idport == src) {                               // We found the record in sources
sletz's avatar
sletz committed
298
            if (fPortList[i].IsUnregistered != 0)
sletz's avatar
sletz committed
299
300
301
302
303
304
305
306
                *fStream << "!!! ERROR !!! : Disconnecting port  " << src << " previoulsy unregistered !" << endl;
            fPortList[i].IsConnected--;
            *fStream << "Disconnecting port " << src << ". " << endl;
            break;
        }
    }
    if (i == 0) // Port is not found
        *fStream << "JackClientDebug : PortDisconnect : port was not found in debug database !" << endl;
307
308
    if (res != 0)
        *fStream << "Client '" << fClientName << "' try to do PortDisconnect but server return " << res << " ." << endl;
sletz's avatar
sletz committed
309
    //*fStream << "Client Port Disconnect with ID done." << endl;
310
    return res;
sletz's avatar
sletz committed
311
312
313
314
}

int JackDebugClient::PortIsMine(jack_port_id_t port_index)
{
sletz's avatar
sletz committed
315
    CheckClient("PortIsMine");
sletz's avatar
sletz committed
316
317
318
319
320
321
322
    return fClient->PortIsMine(port_index);
}

//--------------------
// Context management
//--------------------

323
int JackDebugClient::SetBufferSize(jack_nframes_t buffer_size)
sletz's avatar
sletz committed
324
{
sletz's avatar
sletz committed
325
    CheckClient("SetBufferSize");
326
    return fClient->SetBufferSize(buffer_size);
sletz's avatar
sletz committed
327
328
329
330
}

int JackDebugClient::SetFreeWheel(int onoff)
{
sletz's avatar
sletz committed
331
    CheckClient("SetFreeWheel");
332
333
334
335
336
    if (onoff && fFreewheel)
         *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = ON while FW is already ON " << endl;
    if (!onoff && !fFreewheel)
         *fStream << "!!! ERROR !!! : Freewheel setup seems incorrect : set = OFF while FW is already OFF " << endl;
    fFreewheel = onoff;
sletz's avatar
sletz committed
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
    return fClient->SetFreeWheel(onoff);
}

/*
ShutDown is called:
- from the RT thread when Execute method fails
- possibly from a "closed" notification channel
(Not needed since the synch object used (Sema of Fifo will fails when server quits... see ShutDown))
*/

void JackDebugClient::ShutDown()
{
    fClient->ShutDown();
}

//---------------------
// Transport management
//---------------------

int JackDebugClient::ReleaseTimebase()
{
sletz's avatar
sletz committed
358
    CheckClient("ReleaseTimebase");
sletz's avatar
sletz committed
359
360
361
362
363
    return fClient->ReleaseTimebase();
}

int JackDebugClient::SetSyncCallback(JackSyncCallback sync_callback, void* arg)
{
sletz's avatar
sletz committed
364
    CheckClient("SetSyncCallback");
sletz's avatar
sletz committed
365
366
367
368
369
    return fClient->SetSyncCallback(sync_callback, arg);
}

int JackDebugClient::SetSyncTimeout(jack_time_t timeout)
{
sletz's avatar
sletz committed
370
    CheckClient("SetSyncTimeout");
sletz's avatar
sletz committed
371
372
373
374
375
    return fClient->SetSyncTimeout(timeout);
}

int JackDebugClient::SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg)
{
sletz's avatar
sletz committed
376
    CheckClient("SetTimebaseCallback");
sletz's avatar
sletz committed
377
378
379
    return fClient->SetTimebaseCallback( conditional, timebase_callback, arg);
}

380
void JackDebugClient::TransportLocate(jack_nframes_t frame)
sletz's avatar
sletz committed
381
{
sletz's avatar
sletz committed
382
    CheckClient("TransportLocate");
383
    fClient->TransportLocate(frame);
sletz's avatar
sletz committed
384
385
386
387
}

jack_transport_state_t JackDebugClient::TransportQuery(jack_position_t* pos)
{
sletz's avatar
sletz committed
388
    CheckClient("TransportQuery");
sletz's avatar
sletz committed
389
390
391
392
393
    return fClient->TransportQuery(pos);
}

jack_nframes_t JackDebugClient::GetCurrentTransportFrame()
{
sletz's avatar
sletz committed
394
    CheckClient("GetCurrentTransportFrame");
sletz's avatar
sletz committed
395
396
397
398
399
    return fClient->GetCurrentTransportFrame();
}

int JackDebugClient::TransportReposition(jack_position_t* pos)
{
sletz's avatar
sletz committed
400
    CheckClient("TransportReposition");
sletz's avatar
sletz committed
401
402
403
404
405
    return fClient->TransportReposition(pos);
}

void JackDebugClient::TransportStart()
{
sletz's avatar
sletz committed
406
    CheckClient("TransportStart");
sletz's avatar
sletz committed
407
408
409
410
411
    fClient->TransportStart();
}

void JackDebugClient::TransportStop()
{
sletz's avatar
sletz committed
412
    CheckClient("TransportStop");
sletz's avatar
sletz committed
413
414
415
416
417
418
419
420
421
    fClient->TransportStop();
}

//---------------------
// Callback management
//---------------------

void JackDebugClient::OnShutdown(JackShutdownCallback callback, void *arg)
{
sletz's avatar
sletz committed
422
    CheckClient("OnShutdown");
sletz's avatar
sletz committed
423
424
425
    fClient->OnShutdown(callback, arg);
}

426
427
void JackDebugClient::OnInfoShutdown(JackInfoShutdownCallback callback, void *arg)
{
sletz's avatar
sletz committed
428
    CheckClient("OnInfoShutdown");
429
430
    fClient->OnInfoShutdown(callback, arg);
}
431

432
433
int JackDebugClient::TimeCallback(jack_nframes_t nframes, void *arg)
{
sletz's avatar
sletz committed
434
435
436
    JackDebugClient* client = (JackDebugClient*)arg;
    jack_time_t t1 = GetMicroSeconds();
    int res = client->fProcessTimeCallback(nframes, client->fProcessTimeCallbackArg);
sletz's avatar
sletz committed
437
    if (res == 0) {
sletz's avatar
sletz committed
438
    jack_time_t t2 = GetMicroSeconds();
sletz's avatar
sletz committed
439
440
441
442
        long delta = long((t2 - t1) - client->GetEngineControl()->fPeriodUsecs);
        if (delta > 0 && !client->fFreewheel)
            *client->fStream << "!!! ERROR !!! : Process overload of " << delta << " us" << endl;
    }
sletz's avatar
sletz committed
443
    return res;
444
445
}

sletz's avatar
sletz committed
446
447
int JackDebugClient::SetProcessCallback(JackProcessCallback callback, void *arg)
{
sletz's avatar
sletz committed
448
    CheckClient("SetProcessCallback");
sletz's avatar
sletz committed
449
450
    fProcessTimeCallback = callback;
    fProcessTimeCallbackArg = arg;
451
    return fClient->SetProcessCallback(TimeCallback, this);
sletz's avatar
sletz committed
452
453
454
455
}

int JackDebugClient::SetXRunCallback(JackXRunCallback callback, void *arg)
{
sletz's avatar
sletz committed
456
    CheckClient("SetXRunCallback");
sletz's avatar
sletz committed
457
458
459
460
461
    return fClient->SetXRunCallback(callback, arg);
}

int JackDebugClient::SetInitCallback(JackThreadInitCallback callback, void *arg)
{
sletz's avatar
sletz committed
462
    CheckClient("SetInitCallback");
sletz's avatar
sletz committed
463
464
465
466
467
    return fClient->SetInitCallback(callback, arg);
}

int JackDebugClient::SetGraphOrderCallback(JackGraphOrderCallback callback, void *arg)
{
sletz's avatar
sletz committed
468
    CheckClient("SetGraphOrderCallback");
sletz's avatar
sletz committed
469
470
471
472
473
    return fClient->SetGraphOrderCallback(callback, arg);
}

int JackDebugClient::SetBufferSizeCallback(JackBufferSizeCallback callback, void *arg)
{
sletz's avatar
sletz committed
474
    CheckClient("SetBufferSizeCallback");
sletz's avatar
sletz committed
475
476
477
    return fClient->SetBufferSizeCallback(callback, arg);
}

sletz's avatar
Cleanup    
sletz committed
478
479
int JackDebugClient::SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg)
{
sletz's avatar
sletz committed
480
    CheckClient("SetClientRegistrationCallback");
sletz's avatar
Cleanup    
sletz committed
481
482
483
    return fClient->SetClientRegistrationCallback(callback, arg);
}

sletz's avatar
sletz committed
484
485
int JackDebugClient::SetFreewheelCallback(JackFreewheelCallback callback, void *arg)
{
sletz's avatar
sletz committed
486
    CheckClient("SetFreewheelCallback");
sletz's avatar
sletz committed
487
488
489
490
491
    return fClient->SetFreewheelCallback(callback, arg);
}

int JackDebugClient::SetPortRegistrationCallback(JackPortRegistrationCallback callback, void *arg)
{
sletz's avatar
sletz committed
492
    CheckClient("SetPortRegistrationCallback");
sletz's avatar
sletz committed
493
494
495
    return fClient->SetPortRegistrationCallback(callback, arg);
}

sletz's avatar
sletz committed
496
497
int JackDebugClient::SetPortConnectCallback(JackPortConnectCallback callback, void *arg)
{
sletz's avatar
sletz committed
498
    CheckClient("SetPortConnectCallback");
sletz's avatar
sletz committed
499
500
501
    return fClient->SetPortConnectCallback(callback, arg);
}

502
503
int JackDebugClient::SetPortRenameCallback(JackPortRenameCallback callback, void *arg)
{
sletz's avatar
sletz committed
504
    CheckClient("SetPortRenameCallback");
505
506
507
    return fClient->SetPortRenameCallback(callback, arg);
}

508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
int JackDebugClient::SetSessionCallback(JackSessionCallback callback, void *arg)
{
    CheckClient("SetSessionCallback");
    return fClient->SetSessionCallback(callback, arg);
}

int JackDebugClient::SetLatencyCallback(JackLatencyCallback callback, void *arg)
{
    CheckClient("SetLatencyCallback");
    return fClient->SetLatencyCallback(callback, arg);
}

jack_session_command_t* JackDebugClient::SessionNotify(const char* target, jack_session_event_type_t type, const char* path)
{
    CheckClient("SessionNotify");
    return fClient->SessionNotify(target, type, path);
}

int JackDebugClient::SessionReply(jack_session_event_t* ev)
{
    CheckClient("SessionReply");
    return fClient->SessionReply(ev);
}

char* JackDebugClient::GetUUIDForClientName(const char* client_name)
{
    CheckClient("GetUUIDForClientName");
    return fClient->GetUUIDForClientName(client_name);
}

char* JackDebugClient::GetClientNameByUUID(const char* uuid)
{
    CheckClient("GetClientNameByUUID");
    return fClient->GetClientNameByUUID(uuid);
}

int JackDebugClient::ReserveClientName(const char* client_name, const char* uuid)
{
    CheckClient("ReserveClientName");
    return fClient->ReserveClientName(client_name, uuid);
}

int JackDebugClient::ClientHasSessionCallback(const char* client_name)
{
    CheckClient("ClientHasSessionCallback");
    return fClient->ClientHasSessionCallback(client_name);
}

sletz's avatar
sletz committed
556
557
JackClientControl* JackDebugClient::GetClientControl() const
{
sletz's avatar
sletz committed
558
    CheckClient("GetClientControl");
sletz's avatar
sletz committed
559
560
561
    return fClient->GetClientControl();
}

sletz's avatar
sletz committed
562
563
564
// Internal clients
char* JackDebugClient::GetInternalClientName(int ref)
{
sletz's avatar
sletz committed
565
    CheckClient("GetInternalClientName");
sletz's avatar
sletz committed
566
567
568
569
570
    return fClient->GetInternalClientName(ref);
}

int JackDebugClient::InternalClientHandle(const char* client_name, jack_status_t* status)
{
sletz's avatar
sletz committed
571
    CheckClient("InternalClientHandle");
sletz's avatar
sletz committed
572
573
574
575
576
    return fClient->InternalClientHandle(client_name, status);
}

int JackDebugClient::InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va)
{
sletz's avatar
sletz committed
577
    CheckClient("InternalClientLoad");
sletz's avatar
sletz committed
578
579
580
581
582
    return fClient->InternalClientLoad(client_name, options, status, va);
}

void JackDebugClient::InternalClientUnload(int ref, jack_status_t* status)
{
sletz's avatar
sletz committed
583
    CheckClient("InternalClientUnload");
sletz's avatar
sletz committed
584
585
    fClient->InternalClientUnload(ref, status);
}
sletz's avatar
sletz committed
586

sletz's avatar
sletz committed
587
588
} // end of namespace