Jack2  1.9.9
JackInternalClient.cpp
1 /*
2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2004-2008 Grame
4 
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9 
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14 
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 
19 */
20 
21 #include "JackSystemDeps.h"
22 #include "JackServerGlobals.h"
23 #include "JackGraphManager.h"
24 #include "JackConstants.h"
25 #include "JackInternalClient.h"
26 #include "JackLockedEngine.h"
27 #include "JackServer.h"
28 #include "JackEngineControl.h"
29 #include "JackClientControl.h"
30 #include "JackInternalClientChannel.h"
31 #include "JackTools.h"
32 #include <assert.h>
33 
34 namespace Jack
35 {
36 
37 JackGraphManager* JackInternalClient::fGraphManager = NULL;
38 JackEngineControl* JackInternalClient::fEngineControl = NULL;
39 
40 // Used for external C API (JackAPI.cpp)
41 SERVER_EXPORT JackGraphManager* GetGraphManager()
42 {
43  return JackServerGlobals::fInstance->GetGraphManager();
44 }
45 
46 SERVER_EXPORT JackEngineControl* GetEngineControl()
47 {
48  return JackServerGlobals::fInstance->GetEngineControl();
49 }
50 
51 SERVER_EXPORT JackSynchro* GetSynchroTable()
52 {
53  return JackServerGlobals::fInstance->GetSynchroTable();
54 }
55 
57 {
58  fChannel = new JackInternalClientChannel(server);
59 }
60 
61 JackInternalClient::~JackInternalClient()
62 {
63  delete fChannel;
64 }
65 
66 int JackInternalClient::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
67 {
68  int result;
69  char name_res[JACK_CLIENT_NAME_SIZE + 1];
70  jack_log("JackInternalClient::Open name = %s", name);
71 
72  strncpy(fServerName, server_name, sizeof(fServerName));
73 
74  fChannel->ClientCheck(name, uuid, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result, false);
75  if (result < 0) {
76  int status1 = *status;
77  if (status1 & JackVersionError) {
78  jack_error("JACK protocol mismatch %d", JACK_PROTOCOL_VERSION);
79  } else {
80  jack_error("Client name = %s conflits with another running client", name);
81  }
82  goto error;
83  }
84 
85  strcpy(fClientControl.fName, name_res);
86 
87  // Require new client
88  fChannel->ClientOpen(name_res, &fClientControl.fRefNum, &fEngineControl, &fGraphManager, this, &result);
89  if (result < 0) {
90  jack_error("Cannot open client name = %s", name_res);
91  goto error;
92  }
93 
94  SetupDriverSync(false);
95  JackGlobals::fClientTable[fClientControl.fRefNum] = this;
96  JackGlobals::fServerRunning = true;
97  jack_log("JackInternalClient::Open name = %s refnum = %ld", name_res, fClientControl.fRefNum);
98  return 0;
99 
100 error:
101  fChannel->Close();
102  return -1;
103 }
104 
105 void JackInternalClient::ShutDown()
106 {
107  jack_log("JackInternalClient::ShutDown");
108  JackClient::ShutDown();
109 }
110 
111 JackGraphManager* JackInternalClient::GetGraphManager() const
112 {
113  assert(fGraphManager);
114  return fGraphManager;
115 }
116 
117 JackEngineControl* JackInternalClient::GetEngineControl() const
118 {
119  assert(fEngineControl);
120  return fEngineControl;
121 }
122 
123 JackClientControl* JackInternalClient::GetClientControl() const
124 {
125  return const_cast<JackClientControl*>(&fClientControl);
126 }
127 
128 int JackLoadableInternalClient::Init(const char* so_name)
129 {
130  char path_to_so[JACK_PATH_MAX + 1];
131  BuildClientPath(path_to_so, sizeof(path_to_so), so_name);
132 
133  fHandle = LoadJackModule(path_to_so);
134  jack_log("JackLoadableInternalClient::JackLoadableInternalClient path_to_so = %s", path_to_so);
135 
136  if (fHandle == NULL) {
137  PrintLoadError(so_name);
138  return -1;
139  }
140 
141  fFinish = (FinishCallback)GetJackProc(fHandle, "jack_finish");
142  if (fFinish == NULL) {
143  UnloadJackModule(fHandle);
144  jack_error("symbol jack_finish cannot be found in %s", so_name);
145  return -1;
146  }
147 
148  fDescriptor = (JackDriverDescFunction)GetJackProc(fHandle, "jack_get_descriptor");
149  if (fDescriptor == NULL) {
150  jack_info("No jack_get_descriptor entry-point for %s", so_name);
151  }
152  return 0;
153 }
154 
155 int JackLoadableInternalClient1::Init(const char* so_name)
156 {
157  if (JackLoadableInternalClient::Init(so_name) < 0) {
158  return -1;
159  }
160 
161  fInitialize = (InitializeCallback)GetJackProc(fHandle, "jack_initialize");
162  if (fInitialize == NULL) {
163  UnloadJackModule(fHandle);
164  jack_error("symbol jack_initialize cannot be found in %s", so_name);
165  return -1;
166  }
167 
168  return 0;
169 }
170 
171 int JackLoadableInternalClient2::Init(const char* so_name)
172 {
173  if (JackLoadableInternalClient::Init(so_name) < 0) {
174  return -1;
175  }
176 
177  fInitialize = (InternalInitializeCallback)GetJackProc(fHandle, "jack_internal_initialize");
178  if (fInitialize == NULL) {
179  UnloadJackModule(fHandle);
180  jack_error("symbol jack_internal_initialize cannot be found in %s", so_name);
181  return -1;
182  }
183 
184  return 0;
185 }
186 
187 JackLoadableInternalClient1::JackLoadableInternalClient1(JackServer* server, JackSynchro* table, const char* object_data)
188  : JackLoadableInternalClient(server, table)
189 {
190  strncpy(fObjectData, object_data, JACK_LOAD_INIT_LIMIT);
191 }
192 
193 JackLoadableInternalClient2::JackLoadableInternalClient2(JackServer* server, JackSynchro* table, const JSList* parameters)
194  : JackLoadableInternalClient(server, table)
195 {
196  fParameters = parameters;
197 }
198 
199 JackLoadableInternalClient::~JackLoadableInternalClient()
200 {
201  if (fFinish != NULL) {
202  fFinish(fProcessArg);
203  }
204  if (fHandle != NULL) {
205  UnloadJackModule(fHandle);
206  }
207 }
208 
209 int JackLoadableInternalClient1::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
210 {
211  int res = -1;
212 
213  if (JackInternalClient::Open(server_name, name, uuid, options, status) == 0) {
214  if (fInitialize((jack_client_t*)this, fObjectData) == 0) {
215  res = 0;
216  } else {
217  JackInternalClient::Close();
218  fFinish = NULL;
219  }
220  }
221 
222  return res;
223 }
224 
225 int JackLoadableInternalClient2::Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status)
226 {
227  int res = -1;
228 
229  if (JackInternalClient::Open(server_name, name, uuid, options, status) == 0) {
230  if (fInitialize((jack_client_t*)this, fParameters) == 0) {
231  res = 0;
232  } else {
233  JackInternalClient::Close();
234  fFinish = NULL;
235  }
236  }
237 
238  return res;
239 }
240 
241 } // end of namespace
242 
JackClientChannel for server internal clients.
Inter process synchronization using using Mach semaphore.
SERVER_EXPORT void jack_error(const char *fmt,...)
Definition: JackError.cpp:91
SERVER_EXPORT void jack_info(const char *fmt,...)
Definition: JackError.cpp:99
void SetupDriverSync(bool freewheel)
Definition: JackClient.cpp:140
The Jack server.
Definition: JackServer.h:46
bool Init()
Called once when the thread starts.
Definition: JackClient.cpp:501
JackInternalClient(JackServer *server, JackSynchro *table)
detail::JackClientChannelInterface * fChannel
Definition: JackClient.h:93
static JackEngineControl * fEngineControl
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:107
The base class for clients: share part of the implementation for JackInternalClient and JackLibClient...
Definition: JackClient.h:47