00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef __JackLockedEngine__
00021 #define __JackLockedEngine__
00022
00023 #include "JackEngine.h"
00024 #include "JackMutex.h"
00025 #include "JackTools.h"
00026 #include "JackException.h"
00027
00028 namespace Jack
00029 {
00030
00031 #define TRY_CALL \
00032 try { \
00033
00034 #define CATCH_EXCEPTION_RETURN \
00035 } catch(std::bad_alloc& e) { \
00036 jack_error("Memory allocation error..."); \
00037 return -1; \
00038 } catch(JackTemporaryException& e) { \
00039 jack_error("JackTemporaryException : now quits..."); \
00040 JackTools::KillServer(); \
00041 return -1; \
00042 } catch (...) { \
00043 jack_error("Unknown error..."); \
00044 return -1; \
00045 } \
00046
00047 #define CATCH_ENGINE_EXCEPTION \
00048 } catch(std::bad_alloc& e) { \
00049 jack_error("Memory allocation error..."); \
00050 } catch (...) { \
00051 jack_error("Unknown error..."); \
00052 } \
00053
00054
00058 class SERVER_EXPORT JackLockedEngine : public JackLockAble
00059 {
00060 private:
00061
00062 JackEngine fEngine;
00063
00064 public:
00065
00066 JackLockedEngine(JackGraphManager* manager, JackSynchro* table, JackEngineControl* controler):
00067 fEngine(manager, table, controler)
00068 {}
00069 ~JackLockedEngine()
00070 {}
00071
00072 int Open()
00073 {
00074
00075 TRY_CALL
00076 return fEngine.Open();
00077 CATCH_EXCEPTION_RETURN
00078 }
00079 int Close()
00080 {
00081
00082 TRY_CALL
00083 return fEngine.Close();
00084 CATCH_EXCEPTION_RETURN
00085 }
00086
00087
00088 int ClientCheck(const char* name, char* name_res, int protocol, int options, int* status)
00089 {
00090 TRY_CALL
00091 JackLock lock(this);
00092 return fEngine.ClientCheck(name, name_res, protocol, options, status);
00093 CATCH_EXCEPTION_RETURN
00094 }
00095 int ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
00096 {
00097 TRY_CALL
00098 JackLock lock(this);
00099 return fEngine.ClientExternalOpen(name, pid, ref, shared_engine, shared_client, shared_graph_manager);
00100 CATCH_EXCEPTION_RETURN
00101 }
00102 int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait)
00103 {
00104 TRY_CALL
00105 JackLock lock(this);
00106 return fEngine.ClientInternalOpen(name, ref, shared_engine, shared_manager, client, wait);
00107 CATCH_EXCEPTION_RETURN
00108 }
00109
00110 int ClientExternalClose(int refnum)
00111 {
00112 TRY_CALL
00113 JackLock lock(this);
00114 return fEngine.ClientExternalClose(refnum);
00115 CATCH_EXCEPTION_RETURN
00116 }
00117 int ClientInternalClose(int refnum, bool wait)
00118 {
00119 TRY_CALL
00120 JackLock lock(this);
00121 return fEngine.ClientInternalClose(refnum, wait);
00122 CATCH_EXCEPTION_RETURN
00123 }
00124
00125 int ClientActivate(int refnum, bool is_real_time)
00126 {
00127 TRY_CALL
00128 JackLock lock(this);
00129 return fEngine.ClientActivate(refnum, is_real_time);
00130 CATCH_EXCEPTION_RETURN
00131 }
00132 int ClientDeactivate(int refnum)
00133 {
00134 TRY_CALL
00135 JackLock lock(this);
00136 return fEngine.ClientDeactivate(refnum);
00137 CATCH_EXCEPTION_RETURN
00138 }
00139
00140
00141 int GetInternalClientName(int int_ref, char* name_res)
00142 {
00143 TRY_CALL
00144 JackLock lock(this);
00145 return fEngine.GetInternalClientName(int_ref, name_res);
00146 CATCH_EXCEPTION_RETURN
00147 }
00148 int InternalClientHandle(const char* client_name, int* status, int* int_ref)
00149 {
00150 TRY_CALL
00151 JackLock lock(this);
00152 return fEngine.InternalClientHandle(client_name, status, int_ref);
00153 CATCH_EXCEPTION_RETURN
00154 }
00155 int InternalClientUnload(int refnum, int* status)
00156 {
00157 TRY_CALL
00158 JackLock lock(this);
00159 return fEngine.InternalClientUnload(refnum, status);
00160 CATCH_EXCEPTION_RETURN
00161 }
00162
00163
00164 int PortRegister(int refnum, const char* name, const char *type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port)
00165 {
00166 TRY_CALL
00167 JackLock lock(this);
00168 return fEngine.PortRegister(refnum, name, type, flags, buffer_size, port);
00169 CATCH_EXCEPTION_RETURN
00170 }
00171 int PortUnRegister(int refnum, jack_port_id_t port)
00172 {
00173 TRY_CALL
00174 JackLock lock(this);
00175 return fEngine.PortUnRegister(refnum, port);
00176 CATCH_EXCEPTION_RETURN
00177 }
00178
00179 int PortConnect(int refnum, const char* src, const char* dst)
00180 {
00181 TRY_CALL
00182 JackLock lock(this);
00183 return fEngine.PortConnect(refnum, src, dst);
00184 CATCH_EXCEPTION_RETURN
00185 }
00186 int PortDisconnect(int refnum, const char* src, const char* dst)
00187 {
00188 TRY_CALL
00189 JackLock lock(this);
00190 return fEngine.PortDisconnect(refnum, src, dst);
00191 CATCH_EXCEPTION_RETURN
00192 }
00193
00194 int PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst)
00195 {
00196 TRY_CALL
00197 JackLock lock(this);
00198 return fEngine.PortConnect(refnum, src, dst);
00199 CATCH_EXCEPTION_RETURN
00200 }
00201 int PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst)
00202 {
00203 TRY_CALL
00204 JackLock lock(this);
00205 return fEngine.PortDisconnect(refnum, src, dst);
00206 CATCH_EXCEPTION_RETURN
00207 }
00208
00209 int PortRename(int refnum, jack_port_id_t port, const char* name)
00210 {
00211 TRY_CALL
00212 JackLock lock(this);
00213 return fEngine.PortRename(refnum, port, name);
00214 CATCH_EXCEPTION_RETURN
00215 }
00216
00217
00218 bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
00219 {
00220
00221 return fEngine.Process(cur_cycle_begin, prev_cycle_end);
00222 }
00223
00224
00225 void NotifyXRun(jack_time_t cur_cycle_begin, float delayed_usecs)
00226 {
00227
00228 fEngine.NotifyXRun(cur_cycle_begin, delayed_usecs);
00229 }
00230
00231 void NotifyXRun(int refnum)
00232 {
00233 TRY_CALL
00234 JackLock lock(this);
00235 fEngine.NotifyXRun(refnum);
00236 CATCH_ENGINE_EXCEPTION
00237 }
00238 void NotifyGraphReorder()
00239 {
00240 TRY_CALL
00241 JackLock lock(this);
00242 fEngine.NotifyGraphReorder();
00243 CATCH_ENGINE_EXCEPTION
00244 }
00245 void NotifyBufferSize(jack_nframes_t buffer_size)
00246 {
00247 TRY_CALL
00248 JackLock lock(this);
00249 fEngine.NotifyBufferSize(buffer_size);
00250 CATCH_ENGINE_EXCEPTION
00251 }
00252 void NotifySampleRate(jack_nframes_t sample_rate)
00253 {
00254 TRY_CALL
00255 JackLock lock(this);
00256 fEngine.NotifySampleRate(sample_rate);
00257 CATCH_ENGINE_EXCEPTION
00258 }
00259 void NotifyFreewheel(bool onoff)
00260 {
00261 TRY_CALL
00262 JackLock lock(this);
00263 fEngine.NotifyFreewheel(onoff);
00264 CATCH_ENGINE_EXCEPTION
00265 }
00266
00267 void NotifyFailure(int code, const char* reason)
00268 {
00269 TRY_CALL
00270 JackLock lock(this);
00271 fEngine.NotifyFailure(code, reason);
00272 CATCH_ENGINE_EXCEPTION
00273 }
00274
00275 int GetClientPID(const char* name)
00276 {
00277 TRY_CALL
00278 JackLock lock(this);
00279 return fEngine.GetClientPID(name);
00280 CATCH_EXCEPTION_RETURN
00281 }
00282
00283 int GetClientRefNum(const char* name)
00284 {
00285 TRY_CALL
00286 JackLock lock(this);
00287 return fEngine.GetClientRefNum(name);
00288 CATCH_EXCEPTION_RETURN
00289 }
00290
00291 };
00292
00293 }
00294
00295 #endif
00296