macosx/JackMacEngineRPC.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 General Public License as published by
   6   the Free Software Foundation; either version 2 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 General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackServer.h"
  21 #include "JackLockedEngine.h"
  22 #include "JackRPCEngine.h"
  23 #include "JackMachServerChannel.h"
  24 #include <assert.h>
  25
  26 using namespace Jack;
  27
  28 //-------------------
  29 // Client management
  30 //-------------------
  31
  32 #define rpc_type kern_return_t // for astyle
  33
  34 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)
  35 {
  36     jack_log("rpc_jack_client_check");
  37     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  38     assert(channel);
  39     channel->ClientCheck((char*)name, (char*)name_res, protocol, options, status, result);
  40     return KERN_SUCCESS;
  41 }
  42
  43 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)
  44 {
  45     jack_log("rpc_jack_client_open name = %s", name);
  46     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
  47     assert(channel);
  48     channel->ClientOpen((char*)name, pid, private_port, shared_engine, shared_client, shared_graph, result);
  49     return KERN_SUCCESS;
  50 }
  51
  52 rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
  53 {
  54     jack_log("rpc_jack_client_close");
  55     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  56     assert(channel);
  57     channel->ClientClose(private_port, refnum);
  58     *result = 0;
  59     return KERN_SUCCESS;
  60 }
  61
  62 rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int is_real_time, int* result)
  63 {
  64     jack_log("rpc_jack_client_activate");
  65     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  66     assert(channel);
  67     *result = channel->GetEngine()->ClientActivate(refnum, is_real_time);
  68     return KERN_SUCCESS;
  69 }
  70
  71 rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
  72 {
  73     jack_log("rpc_jack_client_deactivate");
  74     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  75     assert(channel);
  76     *result = channel->GetEngine()->ClientDeactivate(refnum);
  77     return KERN_SUCCESS;
  78 }
  79
  80 //-----------------
  81 // Port management
  82 //-----------------
  83
  84 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)
  85 {
  86     jack_log("rpc_jack_port_register ref = %d name = %s", refnum, name);
  87     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  88     assert(channel);
  89     *result = channel->GetEngine()->PortRegister(refnum, name, type, flags, buffer_size, port_index);
  90     return KERN_SUCCESS;
  91 }
  92
  93 rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
  94 {
  95     jack_log("rpc_jack_port_unregister ref = %d port = %d ", refnum, port);
  96     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  97     assert(channel);
  98     *result = channel->GetEngine()->PortUnRegister(refnum, port);
  99     return KERN_SUCCESS;
 100 }
 101
 102 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)
 103 {
 104     jack_log("rpc_jack_port_connect_name");
 105     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 106     assert(channel);
 107     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
 108     return KERN_SUCCESS;
 109 }
 110
 111 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)
 112 {
 113     jack_log("rpc_jack_port_disconnect_name");
 114     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 115     assert(channel);
 116     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
 117     return KERN_SUCCESS;
 118 }
 119
 120 rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
 121 {
 122     jack_log("rpc_jack_port_connect");
 123     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 124     assert(channel);
 125     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
 126     return KERN_SUCCESS;
 127 }
 128
 129 rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
 130 {
 131     jack_log("rpc_jack_port_disconnect");
 132     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 133     assert(channel);
 134     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
 135     return KERN_SUCCESS;
 136 }
 137
 138 rpc_type server_rpc_jack_port_rename(mach_port_t private_port, int refnum, int port, client_port_name_t name, int* result)
 139 {
 140     jack_log("server_rpc_jack_port_rename");
 141     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 142     assert(channel);
 143     *result = channel->GetEngine()->PortRename(refnum, port, name);
 144     return KERN_SUCCESS;
 145 }
 146
 147 //------------------------
 148 // Buffer size, freewheel
 149 //------------------------
 150
 151 rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
 152 {
 153     jack_log("server_rpc_jack_set_buffer_size");
 154     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 155     assert(channel);
 156     *result = channel->GetServer()->SetBufferSize(buffer_size);
 157     return KERN_SUCCESS;
 158 }
 159
 160 rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
 161 {
 162     jack_log("server_rpc_jack_set_freewheel");
 163     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 164     assert(channel);
 165     *result = channel->GetServer()->SetFreewheel(onoff);
 166     return KERN_SUCCESS;
 167 }
 168
 169 //----------------------
 170 // Transport management
 171 //----------------------
 172
 173 rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
 174 {
 175     jack_log("server_rpc_jack_release_timebase");
 176     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 177     assert(channel);
 178     *result = channel->GetServer()->ReleaseTimebase(refnum);
 179     return KERN_SUCCESS;
 180 }
 181
 182 rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
 183 {
 184     jack_log("server_rpc_jack_set_timebase_callback");
 185     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 186     assert(channel);
 187     *result = channel->GetServer()->SetTimebaseCallback(refnum, conditional);
 188     return KERN_SUCCESS;
 189 }
 190
 191 //------------------
 192 // Internal clients
 193 //------------------
 194
 195 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)
 196 {
 197     jack_log("server_rpc_jack_get_internal_clientname");
 198     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 199     assert(channel);
 200     *result = channel->GetServer()->GetEngine()->GetInternalClientName(int_ref, (char*)name_res);
 201     return KERN_SUCCESS;
 202 }
 203
 204 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)
 205 {
 206     jack_log("server_rpc_jack_internal_clienthandle");
 207     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 208     assert(channel);
 209     *result = channel->GetServer()->GetEngine()->InternalClientHandle(client_name, status, int_ref);
 210     return KERN_SUCCESS;
 211 }
 212
 213 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)
 214 {
 215     jack_log("server_rpc_jack_internal_clientload");
 216     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 217     assert(channel);
 218     *result = channel->GetServer()->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);
 219     return KERN_SUCCESS;
 220 }
 221
 222 rpc_type server_rpc_jack_internal_clientunload(mach_port_t private_port, int refnum, int int_ref, int* status, int* result)
 223 {
 224     jack_log("server_rpc_jack_internal_clientunload");
 225     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 226     assert(channel);
 227     *result = channel->GetServer()->GetEngine()->InternalClientUnload(int_ref, status);
 228     return KERN_SUCCESS;
 229 }
 230
 231 //-----------------
 232 // RT notification
 233 //-----------------
 234
 235 rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
 236 {
 237     jack_log("rpc_jack_client_rt_notify ref = %d notify = %d value = %d", refnum, notify, value);
 238     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
 239     assert(channel);
 240     assert(channel->GetServer());
 241     channel->GetServer()->Notify(refnum, notify, value);
 242     return KERN_SUCCESS;
 243 }