Jack2  1.9.10
JackGenericClientChannel.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 "JackGenericClientChannel.h"
21 #include "JackClient.h"
22 #include "JackGlobals.h"
23 #include "JackError.h"
24 
25 namespace Jack
26 {
27 
28 JackGenericClientChannel::JackGenericClientChannel()
29 {}
30 
31 JackGenericClientChannel::~JackGenericClientChannel()
32 {}
33 
34 int JackGenericClientChannel::ServerCheck(const char* server_name)
35 {
36  jack_log("JackGenericClientChannel::ServerCheck = %s", server_name);
37 
38  // Connect to server
39  if (fRequest->Connect(jack_server_dir, server_name, 0) < 0) {
40  jack_error("Cannot connect to server request channel");
41  return -1;
42  } else {
43  return 0;
44  }
45 }
46 
47 void JackGenericClientChannel::ServerSyncCall(JackRequest* req, JackResult* res, int* result)
48 {
49  // Check call context
50  if (jack_tls_get(JackGlobals::fNotificationThread)) {
51  jack_error("Cannot callback the server in notification thread!");
52  *result = -1;
53  return;
54  }
55 
56  if (!JackGlobals::fServerRunning) {
57  jack_error("Server is not running");
58  *result = -1;
59  return;
60  }
61 
62  if (req->Write(fRequest) < 0) {
63  jack_error("Could not write request type = %ld", req->fType);
64  *result = -1;
65  return;
66  }
67 
68  if (res->Read(fRequest) < 0) {
69  jack_error("Could not read result type = %ld", req->fType);
70  *result = -1;
71  return;
72  }
73 
74  *result = res->fResult;
75 }
76 
77 void JackGenericClientChannel::ServerAsyncCall(JackRequest* req, JackResult* res, int* result)
78 {
79  // Check call context
80  if (jack_tls_get(JackGlobals::fNotificationThread)) {
81  jack_error("Cannot callback the server in notification thread!");
82  *result = -1;
83  return;
84  }
85 
86  if (!JackGlobals::fServerRunning) {
87  jack_error("Server is not running");
88  *result = -1;
89  return;
90  }
91 
92  if (req->Write(fRequest) < 0) {
93  jack_error("Could not write request type = %ld", req->fType);
94  *result = -1;
95  } else {
96  *result = 0;
97  }
98 }
99 
100 void JackGenericClientChannel::ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status, int* result, int open)
101 {
102  JackClientCheckRequest req(name, protocol, options, uuid, open);
103  JackClientCheckResult res;
104  ServerSyncCall(&req, &res, result);
105  *status = res.fStatus;
106  strcpy(name_res, res.fName);
107 }
108 
109 void JackGenericClientChannel::ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
110 {
111  JackClientOpenRequest req(name, pid, uuid);
112  JackClientOpenResult res;
113  ServerSyncCall(&req, &res, result);
114  *shared_engine = res.fSharedEngine;
115  *shared_client = res.fSharedClient;
116  *shared_graph = res.fSharedGraph;
117 }
118 
119 void JackGenericClientChannel::ClientClose(int refnum, int* result)
120 {
121  JackClientCloseRequest req(refnum);
122  JackResult res;
123  ServerSyncCall(&req, &res, result);
124 }
125 
126 void JackGenericClientChannel::ClientActivate(int refnum, int is_real_time, int* result)
127 {
128  JackActivateRequest req(refnum, is_real_time);
129  JackResult res;
130  ServerSyncCall(&req, &res, result);
131 }
132 
133 void JackGenericClientChannel::ClientDeactivate(int refnum, int* result)
134 {
135  JackDeactivateRequest req(refnum);
136  JackResult res;
137  ServerSyncCall(&req, &res, result);
138 }
139 
140 void JackGenericClientChannel::PortRegister(int refnum, const char* name, const char* type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result)
141 {
142  JackPortRegisterRequest req(refnum, name, type, flags, buffer_size);
143  JackPortRegisterResult res;
144  ServerSyncCall(&req, &res, result);
145  *port_index = res.fPortIndex;
146 }
147 
148 void JackGenericClientChannel::PortUnRegister(int refnum, jack_port_id_t port_index, int* result)
149 {
150  JackPortUnRegisterRequest req(refnum, port_index);
151  JackResult res;
152  ServerSyncCall(&req, &res, result);
153 }
154 
155 void JackGenericClientChannel::PortConnect(int refnum, const char* src, const char* dst, int* result)
156 {
157  JackPortConnectNameRequest req(refnum, src, dst);
158  JackResult res;
159  ServerSyncCall(&req, &res, result);
160 }
161 
162 void JackGenericClientChannel::PortDisconnect(int refnum, const char* src, const char* dst, int* result)
163 {
164  JackPortDisconnectNameRequest req(refnum, src, dst);
165  JackResult res;
166  ServerSyncCall(&req, &res, result);
167 }
168 
169 void JackGenericClientChannel::PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
170 {
171  JackPortConnectRequest req(refnum, src, dst);
172  JackResult res;
173  ServerSyncCall(&req, &res, result);
174 }
175 
176 void JackGenericClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
177 {
178  JackPortDisconnectRequest req(refnum, src, dst);
179  JackResult res;
180  ServerSyncCall(&req, &res, result);
181 }
182 
183 void JackGenericClientChannel::PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
184 {
185  JackPortRenameRequest req(refnum, port, name);
186  JackResult res;
187  ServerSyncCall(&req, &res, result);
188 }
189 
190 void JackGenericClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
191 {
192  JackSetBufferSizeRequest req(buffer_size);
193  JackResult res;
194  ServerSyncCall(&req, &res, result);
195 }
196 
197 void JackGenericClientChannel::SetFreewheel(int onoff, int* result)
198 {
199  JackSetFreeWheelRequest req(onoff);
200  JackResult res;
201  ServerSyncCall(&req, &res, result);
202 }
203 
204 void JackGenericClientChannel::ComputeTotalLatencies(int* result)
205 {
206  JackComputeTotalLatenciesRequest req;
207  JackResult res;
208  ServerSyncCall(&req, &res, result);
209 }
210 
211 void JackGenericClientChannel::SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result)
212 {
213  JackSessionNotifyRequest req(refnum, path, type, target);
214  JackSessionNotifyResult res;
215  int intresult;
216  ServerSyncCall(&req, &res, &intresult);
217  *result = res.GetCommands();
218 }
219 
220 void JackGenericClientChannel::SessionReply(int refnum, int* result)
221 {
222  JackSessionReplyRequest req(refnum);
223  JackResult res;
224  ServerSyncCall(&req, &res, result);
225 }
226 
227 void JackGenericClientChannel::GetUUIDForClientName(int refnum, const char* client_name, char* uuid_res, int* result)
228 {
229  JackGetUUIDRequest req(client_name);
230  JackUUIDResult res;
231  ServerSyncCall(&req, &res, result);
232  strncpy(uuid_res, res.fUUID, JACK_UUID_SIZE);
233 }
234 
235 void JackGenericClientChannel::GetClientNameForUUID(int refnum, const char* uuid, char* name_res, int* result)
236 {
237  JackGetClientNameRequest req(uuid);
238  JackClientNameResult res;
239  ServerSyncCall(&req, &res, result);
240  strncpy(name_res, res.fName, JACK_CLIENT_NAME_SIZE);
241 }
242 
243 void JackGenericClientChannel::ClientHasSessionCallback(const char* client_name, int* result)
244 {
245  JackClientHasSessionCallbackRequest req(client_name);
246  JackResult res;
247  ServerSyncCall(&req, &res, result);
248 }
249 
250 void JackGenericClientChannel::ReserveClientName(int refnum, const char* client_name, const char* uuid, int* result)
251 {
252  JackReserveNameRequest req(refnum, client_name, uuid);
253  JackResult res;
254  ServerSyncCall(&req, &res, result);
255 }
256 
257 void JackGenericClientChannel::ReleaseTimebase(int refnum, int* result)
258 {
259  JackReleaseTimebaseRequest req(refnum);
260  JackResult res;
261  ServerSyncCall(&req, &res, result);
262 }
263 
264 void JackGenericClientChannel::SetTimebaseCallback(int refnum, int conditional, int* result)
265 {
266  JackSetTimebaseCallbackRequest req(refnum, conditional);
267  JackResult res;
268  ServerSyncCall(&req, &res, result);
269 }
270 
271 void JackGenericClientChannel::GetInternalClientName(int refnum, int int_ref, char* name_res, int* result)
272 {
273  JackGetInternalClientNameRequest req(refnum, int_ref);
274  JackGetInternalClientNameResult res;
275  ServerSyncCall(&req, &res, result);
276  strcpy(name_res, res.fName);
277 }
278 
279 void JackGenericClientChannel::InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result)
280 {
281  JackInternalClientHandleRequest req(refnum, client_name);
282  JackInternalClientHandleResult res;
283  ServerSyncCall(&req, &res, result);
284  *int_ref = res.fIntRefNum;
285  *status = res.fStatus;
286 }
287 
288 void JackGenericClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int uuid, int* result)
289 {
290  JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options, uuid);
291  JackInternalClientLoadResult res;
292  ServerSyncCall(&req, &res, result);
293  *int_ref = res.fIntRefNum;
294  *status = res.fStatus;
295 }
296 
297 void JackGenericClientChannel::InternalClientUnload(int refnum, int int_ref, int* status, int* result)
298 {
299  JackInternalClientUnloadRequest req(refnum, int_ref);
300  JackInternalClientUnloadResult res;
301  ServerSyncCall(&req, &res, result);
302  *status = res.fStatus;
303 }
304 
305 } // end of namespace
306 
307 
308 
309 
310