Jack2 1.9.6

JackMacEngineRPC.cpp

00001 /*
00002 Copyright (C) 2004-2008 Grame
00003 
00004 This program is free software; you can redistribute it and/or modify
00005   it under the terms of the GNU General Public License as published by
00006   the Free Software Foundation; either version 2 of the License, or
00007   (at your option) any later version.
00008 
00009   This program is distributed in the hope that it will be useful,
00010   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012   GNU General Public License for more details.
00013 
00014   You should have received a copy of the GNU General Public License
00015   along with this program; if not, write to the Free Software
00016   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00017 
00018 */
00019 
00020 #include "JackServer.h"
00021 #include "JackNotification.h"
00022 #include "JackLockedEngine.h"
00023 #include "JackRPCEngine.h"
00024 #include "JackMachServerChannel.h"
00025 #include "JackException.h"
00026 #include <assert.h>
00027 
00028 using namespace Jack;
00029 
00030 //-------------------
00031 // Client management
00032 //-------------------
00033 
00034 #define rpc_type kern_return_t // for astyle
00035 
00036 rpc_type server_rpc_jack_client_check(mach_port_t private_port, client_name_t name, client_name_t name_res, int protocol, int options, int* status, int* result)
00037 {
00038     jack_log("rpc_jack_client_check");
00039     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00040     assert(channel);
00041     channel->ClientCheck((char*)name, (char*)name_res, protocol, options, status, result);
00042     return KERN_SUCCESS;
00043 }
00044 
00045 rpc_type server_rpc_jack_client_open(mach_port_t server_port, client_name_t name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
00046 {
00047     jack_log("rpc_jack_client_open name = %s", name);
00048     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
00049     assert(channel);
00050     channel->ClientOpen((char*)name, pid, private_port, shared_engine, shared_client, shared_graph, result);
00051     return KERN_SUCCESS;
00052 }
00053 
00054 rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
00055 {
00056     jack_log("rpc_jack_client_close");
00057     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00058     assert(channel);
00059     channel->ClientClose(private_port, refnum);
00060     *result = 0;
00061     return KERN_SUCCESS;
00062 }
00063 
00064 rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int is_real_time, int* result)
00065 {
00066     jack_log("rpc_jack_client_activate");
00067     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00068     assert(channel);
00069     *result = channel->GetEngine()->ClientActivate(refnum, is_real_time);
00070     return KERN_SUCCESS;
00071 }
00072 
00073 rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
00074 {
00075     jack_log("rpc_jack_client_deactivate");
00076     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00077     assert(channel);
00078     *result = channel->GetEngine()->ClientDeactivate(refnum);
00079     return KERN_SUCCESS;
00080 }
00081 
00082 //-----------------
00083 // Port management
00084 //-----------------
00085 
00086 rpc_type server_rpc_jack_port_register(mach_port_t private_port, int refnum, client_port_name_t name, client_port_type_t type, unsigned int flags, unsigned int buffer_size, unsigned int* port_index, int* result)
00087 {
00088     jack_log("rpc_jack_port_register ref = %d name = %s", refnum, name);
00089     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00090     assert(channel);
00091     *result = channel->GetEngine()->PortRegister(refnum, name, type, flags, buffer_size, port_index);
00092     return KERN_SUCCESS;
00093 }
00094 
00095 rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
00096 {
00097     jack_log("rpc_jack_port_unregister ref = %d port = %d ", refnum, port);
00098     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00099     assert(channel);
00100     *result = channel->GetEngine()->PortUnRegister(refnum, port);
00101     return KERN_SUCCESS;
00102 }
00103 
00104 rpc_type server_rpc_jack_port_connect_name(mach_port_t private_port, int refnum, client_port_name_t src, client_port_name_t dst, int* result)
00105 {
00106     jack_log("rpc_jack_port_connect_name");
00107     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00108     assert(channel);
00109     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
00110     return KERN_SUCCESS;
00111 }
00112 
00113 rpc_type server_rpc_jack_port_disconnect_name(mach_port_t private_port, int refnum, client_port_name_t src, client_port_name_t dst, int* result)
00114 {
00115     jack_log("rpc_jack_port_disconnect_name");
00116     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00117     assert(channel);
00118     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
00119     return KERN_SUCCESS;
00120 }
00121 
00122 rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
00123 {
00124     jack_log("rpc_jack_port_connect");
00125     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00126     assert(channel);
00127     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
00128     return KERN_SUCCESS;
00129 }
00130 
00131 rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
00132 {
00133     jack_log("rpc_jack_port_disconnect");
00134     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00135     assert(channel);
00136     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
00137     return KERN_SUCCESS;
00138 }
00139 
00140 rpc_type server_rpc_jack_port_rename(mach_port_t private_port, int refnum, int port, client_port_name_t name, int* result)
00141 {
00142     jack_log("server_rpc_jack_port_rename");
00143     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00144     assert(channel);
00145     *result = channel->GetEngine()->PortRename(refnum, port, name);
00146     return KERN_SUCCESS;
00147 }
00148 
00149 //------------------------
00150 // Buffer size, freewheel
00151 //------------------------
00152 
00153 rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
00154 {
00155     jack_log("server_rpc_jack_set_buffer_size");
00156     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00157     assert(channel);
00158     *result = channel->GetServer()->SetBufferSize(buffer_size);
00159     return KERN_SUCCESS;
00160 }
00161 
00162 rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
00163 {
00164     jack_log("server_rpc_jack_set_freewheel");
00165     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00166     assert(channel);
00167     *result = channel->GetServer()->SetFreewheel(onoff);
00168     return KERN_SUCCESS;
00169 }
00170 
00171 //----------------------
00172 // Transport management
00173 //----------------------
00174 
00175 rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
00176 {
00177     jack_log("server_rpc_jack_release_timebase");
00178     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00179     assert(channel);
00180     *result = channel->GetServer()->ReleaseTimebase(refnum);
00181     return KERN_SUCCESS;
00182 }
00183 
00184 rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
00185 {
00186     jack_log("server_rpc_jack_set_timebase_callback");
00187     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00188     assert(channel);
00189     *result = channel->GetServer()->SetTimebaseCallback(refnum, conditional);
00190     return KERN_SUCCESS;
00191 }
00192 
00193 //------------------
00194 // Internal clients
00195 //------------------
00196 
00197 rpc_type server_rpc_jack_get_internal_clientname(mach_port_t private_port, int refnum, int int_ref, client_name_t name_res, int* result)
00198 {
00199     jack_log("server_rpc_jack_get_internal_clientname");
00200     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00201     assert(channel);
00202     *result = channel->GetServer()->GetEngine()->GetInternalClientName(int_ref, (char*)name_res);
00203     return KERN_SUCCESS;
00204 }
00205 
00206 rpc_type server_rpc_jack_internal_clienthandle(mach_port_t private_port, int refnum, client_name_t client_name, int* status, int* int_ref, int* result)
00207 {
00208     jack_log("server_rpc_jack_internal_clienthandle");
00209     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00210     assert(channel);
00211     *result = channel->GetServer()->GetEngine()->InternalClientHandle(client_name, status, int_ref);
00212     return KERN_SUCCESS;
00213 }
00214 
00215 rpc_type server_rpc_jack_internal_clientload(mach_port_t private_port, int refnum, client_name_t client_name, so_name_t so_name, objet_data_t objet_data, int options, int* status, int* int_ref, int* result)
00216 {
00217     jack_log("server_rpc_jack_internal_clientload");
00218     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00219     assert(channel);
00220     *result = channel->GetServer()->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);
00221     return KERN_SUCCESS;
00222 }
00223 
00224 rpc_type server_rpc_jack_internal_clientunload(mach_port_t private_port, int refnum, int int_ref, int* status, int* result)
00225 {
00226     jack_log("server_rpc_jack_internal_clientunload");
00227     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00228     assert(channel);
00229     *result = channel->GetServer()->GetEngine()->InternalClientUnload(int_ref, status);
00230     return KERN_SUCCESS;
00231 }
00232 
00233 //-----------------
00234 // RT notification
00235 //-----------------
00236 
00237 rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
00238 {
00239     jack_log("rpc_jack_client_rt_notify ref = %d notify = %d value = %d", refnum, notify, value);
00240     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
00241     assert(channel);
00242     assert(channel->GetServer());
00243     
00244     if (notify == kQUIT) {
00245         throw JackQuitException();
00246     } else {
00247         channel->GetServer()->Notify(refnum, notify, value);
00248         return KERN_SUCCESS;
00249     }
00250 }