JackMacEngineRPC.cpp

00001 /*
00002 Copyright (C) 2004-2006 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 "JackEngine.h"
00022 #include "JackRPCEngine.h"
00023 #include "JackMachServerChannel.h"
00024 #include <assert.h>
00025 
00026 using namespace Jack;
00027 
00028 //-------------------
00029 // Client management
00030 //-------------------
00031 
00032 #define rpc_type kern_return_t // for astyle
00033 
00034 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)
00035 {
00036     JackLog("rpc_jack_client_new %s\n", name);
00037     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
00038     assert(channel);
00039     channel->AddClient((char*)name, private_port, shared_engine, shared_client, shared_graph, result);
00040     return KERN_SUCCESS;
00041 }
00042 
00043 rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
00044 {
00045     JackLog("rpc_jack_client_close\n");
00046     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00047     assert(channel);
00048     channel->RemoveClient(private_port, refnum);
00049     *result = 0;
00050     return KERN_SUCCESS;
00051 }
00052 
00053 rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int* result)
00054 {
00055     JackLog("rpc_jack_client_activate\n");
00056     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00057     assert(channel);
00058     *result = channel->GetServer()->Activate(refnum);
00059     return KERN_SUCCESS;
00060 }
00061 
00062 rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
00063 {
00064     JackLog("rpc_jack_client_deactivate\n");
00065     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00066     assert(channel);
00067     *result = channel->GetServer()->Deactivate(refnum);
00068     return KERN_SUCCESS;
00069 }
00070 
00071 //-----------------
00072 // Port management
00073 //-----------------
00074 
00075 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)
00076 {
00077     JackLog("rpc_jack_port_register %ld %s\n", refnum, name);
00078     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00079     assert(channel);
00080     *result = channel->GetEngine()->PortRegister(refnum, name, flags, buffer_size, port_index);
00081     return KERN_SUCCESS;
00082 }
00083 
00084 rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
00085 {
00086     JackLog("rpc_jack_port_unregister %ld %ld \n", refnum, port);
00087     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00088     assert(channel);
00089     *result = channel->GetEngine()->PortUnRegister(refnum, port);
00090     return KERN_SUCCESS;
00091 }
00092 
00093 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)
00094 {
00095     JackLog("rpc_jack_port_connect_name\n");
00096     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00097     assert(channel);
00098     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
00099     return KERN_SUCCESS;
00100 }
00101 
00102 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)
00103 {
00104     JackLog("rpc_jack_port_disconnect_name\n");
00105     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00106     assert(channel);
00107     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
00108     return KERN_SUCCESS;
00109 }
00110 
00111 rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
00112 {
00113     JackLog("rpc_jack_port_connect\n");
00114     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00115     assert(channel);
00116     *result = channel->GetEngine()->PortConnect(refnum, src, dst);
00117     return KERN_SUCCESS;
00118 }
00119 
00120 rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
00121 {
00122     JackLog("rpc_jack_port_disconnect\n");
00123     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00124     assert(channel);
00125     *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
00126     return KERN_SUCCESS;
00127 }
00128 
00129 //------------------------
00130 // Buffer size, freewheel
00131 //------------------------
00132 
00133 rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
00134 {
00135     JackLog("server_rpc_jack_set_buffer_size\n");
00136     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00137     assert(channel);
00138     *result = channel->GetServer()->SetBufferSize(buffer_size);
00139     return KERN_SUCCESS;
00140 }
00141 
00142 rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
00143 {
00144     JackLog("server_rpc_jack_set_freewheel\n");
00145     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00146     assert(channel);
00147     *result = channel->GetServer()->SetFreewheel(onoff);
00148     return KERN_SUCCESS;
00149 }
00150 
00151 //----------------------
00152 // Transport management
00153 //----------------------
00154 
00155 rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
00156 {
00157     JackLog("server_rpc_jack_release_timebase\n");
00158     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00159     assert(channel);
00160     *result = channel->GetServer()->GetEngine()->ReleaseTimebase(refnum);
00161     return KERN_SUCCESS;
00162 }
00163 
00164 rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
00165 {
00166     JackLog("server_rpc_jack_set_timebase_callback\n");
00167     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00168     assert(channel);
00169     *result = channel->GetServer()->GetEngine()->SetTimebaseCallback(refnum, conditional);
00170     return KERN_SUCCESS;
00171 }
00172 
00173 //-----------------
00174 // RT notification
00175 //-----------------
00176 
00177 rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
00178 {
00179     JackLog("rpc_jack_client_rt_notify ref = %ld notify = %ld value = %ld\n", refnum, notify, value);
00180     JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
00181     assert(channel);
00182     assert(channel->GetServer());
00183     channel->GetServer()->Notify(refnum, notify, value);
00184     return KERN_SUCCESS;
00185 }

Generated on Wed Jan 10 11:42:45 2007 for Jackdmp by  doxygen 1.4.5