macosx/JackMacEngineRPC.cpp

   1 /*
   2 Copyright (C) 2004-2006 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 "JackEngine.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_new(mach_port_t server_port, client_name_t name, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
  35 {
  36     JackLog("rpc_jack_client_new %s\n", name);
  37     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
  38     assert(channel);
  39     channel->AddClient((char*)name, private_port, shared_engine, shared_client, shared_graph, result);
  40     return KERN_SUCCESS;
  41 }
  42
  43 rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
  44 {
  45     JackLog("rpc_jack_client_close\n");
  46     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  47     assert(channel);
  48     channel->RemoveClient(private_port, refnum);
  49     *result = 0;
  50     return KERN_SUCCESS;
  51 }
  52
  53 rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int* result)
  54 {
  55     JackLog("rpc_jack_client_activate\n");
  56     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  57     assert(channel);
  58     *result = channel->GetServer()->Activate(refnum);
  59     return KERN_SUCCESS;
  60 }
  61
  62 rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
  63 {
  64     JackLog("rpc_jack_client_deactivate\n");
  65     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  66     assert(channel);
  67     *result = channel->GetServer()->Deactivate(refnum);
  68     return KERN_SUCCESS;
  69 }
  70
  71 //-----------------
  72 // Port management
  73 //-----------------
  74
  75 rpc_type server_rpc_jack_port_register(mach_port_t private_port, int refnum, client_port_name_t name, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result)
  76 {
  77     JackLog("rpc_jack_port_register %ld %s\n", refnum, name);
  78     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  79     assert(channel);
  80     *result = channel->GetEngine()->PortRegister(refnum, name, flags, buffer_size, port_index);
  81     return KERN_SUCCESS;
  82 }
  83
  84 rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
  85 {
  86     JackLog("rpc_jack_port_unregister %ld %ld \n", refnum, port);
  87     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  88     assert(channel);
  89     *result = channel->GetEngine()->PortUnRegister(refnum, port);
  90     return KERN_SUCCESS;
  91 }
  92
  93 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)
  94 {
  95     JackLog("rpc_jack_port_connect_name\n");
  96     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
  97     assert(channel);
  98     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
  99     return KERN_SUCCESS;
 100 }
 101
 102 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)
 103 {
 104     JackLog("rpc_jack_port_disconnect_name\n");
 105     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 106     assert(channel);
 107     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
 108     return KERN_SUCCESS;
 109 }
 110
 111 rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
 112 {
 113     JackLog("rpc_jack_port_connect\n");
 114     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 115     assert(channel);
 116     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
 117     return KERN_SUCCESS;
 118 }
 119
 120 rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
 121 {
 122     JackLog("rpc_jack_port_disconnect\n");
 123     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 124     assert(channel);
 125     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
 126     return KERN_SUCCESS;
 127 }
 128
 129 //------------------------
 130 // Buffer size, freewheel
 131 //------------------------
 132
 133 rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
 134 {
 135     JackLog("server_rpc_jack_set_buffer_size\n");
 136     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 137     assert(channel);
 138     *result = channel->GetServer()->SetBufferSize(buffer_size);
 139     return KERN_SUCCESS;
 140 }
 141
 142 rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
 143 {
 144     JackLog("server_rpc_jack_set_freewheel\n");
 145     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 146     assert(channel);
 147     *result = channel->GetServer()->SetFreewheel(onoff);
 148     return KERN_SUCCESS;
 149 }
 150
 151 //----------------------
 152 // Transport management
 153 //----------------------
 154
 155 rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
 156 {
 157     JackLog("server_rpc_jack_release_timebase\n");
 158     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 159     assert(channel);
 160     *result = channel->GetServer()->GetEngine()->ReleaseTimebase(refnum);
 161     return KERN_SUCCESS;
 162 }
 163
 164 rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
 165 {
 166     JackLog("server_rpc_jack_set_timebase_callback\n");
 167     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
 168     assert(channel);
 169     *result = channel->GetServer()->GetEngine()->SetTimebaseCallback(refnum, conditional);
 170     return KERN_SUCCESS;
 171 }
 172
 173 //-----------------
 174 // RT notification
 175 //-----------------
 176
 177 rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
 178 {
 179     JackLog("rpc_jack_client_rt_notify ref = %ld notify = %ld value = %ld\n", refnum, notify, value);
 180     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
 181     assert(channel);
 182     assert(channel->GetServer());
 183     channel->GetServer()->Notify(refnum, notify, value);
 184     return KERN_SUCCESS;
 185 }