← Back to branch summary

~ubuntu-branches/debian/sid/jackd2/sid

« back to all changes in this revision

Viewing changes to macosx/JackMacEngineRPC.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adrian Knoth
  • Date: 2011-03-31 13:54:50 UTC
  • mfrom: (1.1.3 upstream) (2.1.4 experimental)
  • Revision ID: james.westby@ubuntu.com-20110331135450-zafc1di024kzeu31
Tags: 1.9.7~dfsg-1
* New upstream version 1.9.7 (ALSA resume, new latency API)
* Build with --mixed on i386 to be compatible with amd64.
* Don't patch jack_connect for fast consecutive calls anymore, it's now
  using the same code as in jackd1 and waits for the port connection to
  appear.

Show diffs side-by-side

added added

removed removed

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