1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
Copyright (C) 2004-2008 Grame
This program is free software; you can redistribute it and/or modify
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
(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
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __JackDebugClient__
#define __JackDebugClient__
#define MAX_PORT_HISTORY 2048
#include "JackClient.h"
#include <list>
#include <fstream>
namespace Jack
{
/*!
\brief Follow a single port.
*/
typedef struct
{
jack_port_id_t idport;
char name[JACK_PORT_NAME_SIZE]; //portname
int IsConnected;
int IsUnregistered;
}
PortFollower;
/*!
\brief A "decorator" debug client to validate API use.
*/
class JackDebugClient : public JackClient
{
protected:
JackClient* fClient;
std::ofstream* fStream;
PortFollower fPortList[MAX_PORT_HISTORY]; // Arbitrary value... To be tuned...
int fTotalPortNumber; // The total number of port opened and maybe closed. Historical view.
int fOpenPortNumber; // The current number of opened port.
int fIsActivated;
int fIsDeactivated;
int fIsClosed;
bool fFreewheel;
char fClientName[JACK_CLIENT_NAME_SIZE+1];
JackProcessCallback fProcessTimeCallback;
void* fProcessTimeCallbackArg;
public:
JackDebugClient(JackClient* fTheClient);
virtual ~JackDebugClient();
virtual int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status);
int Close();
virtual JackGraphManager* GetGraphManager() const;
virtual JackEngineControl* GetEngineControl() const;
// Notifications
int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
int Activate();
int Deactivate();
// Context
int SetBufferSize(jack_nframes_t buffer_size);
int SetFreeWheel(int onoff);
int ComputeTotalLatencies();
void ShutDown(jack_status_t code, const char* message);
jack_native_thread_t GetThreadID();
// Port management
int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
int PortUnRegister(jack_port_id_t port);
int PortConnect(const char* src, const char* dst);
int PortDisconnect(const char* src, const char* dst);
int PortDisconnect(jack_port_id_t src);
int PortIsMine(jack_port_id_t port_index);
int PortRename(jack_port_id_t port_index, const char* name);
// Transport
int ReleaseTimebase();
int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
int SetSyncTimeout(jack_time_t timeout);
int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
void TransportLocate(jack_nframes_t frame);
jack_transport_state_t TransportQuery(jack_position_t* pos);
jack_nframes_t GetCurrentTransportFrame();
int TransportReposition(const jack_position_t* pos);
void TransportStart();
void TransportStop();
// Callbacks
void OnShutdown(JackShutdownCallback callback, void *arg);
void OnInfoShutdown(JackInfoShutdownCallback callback, void *arg);
int SetProcessCallback(JackProcessCallback callback, void* arg);
int SetXRunCallback(JackXRunCallback callback, void* arg);
int SetInitCallback(JackThreadInitCallback callback, void* arg);
int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
int SetSessionCallback(JackSessionCallback callback, void *arg);
int SetLatencyCallback(JackLatencyCallback callback, void *arg);
// Internal clients
char* GetInternalClientName(int ref);
int InternalClientHandle(const char* client_name, jack_status_t* status);
int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
void InternalClientUnload(int ref, jack_status_t* status);
// RT Thread
int SetProcessThread(JackThreadCallback fun, void *arg);
// Session API
jack_session_command_t* SessionNotify(const char* target, jack_session_event_type_t type, const char* path);
int SessionReply(jack_session_event_t* ev);
char* GetUUIDForClientName(const char* client_name);
char* GetClientNameByUUID(const char* uuid);
int ReserveClientName(const char* client_name, const char* uuid);
int ClientHasSessionCallback(const char* client_name);
JackClientControl* GetClientControl() const;
void CheckClient(const char* function_name) const;
static int TimeCallback(jack_nframes_t nframes, void *arg);
};
} // end of namespace
#endif
|
