Mercurial > audio-send
comparison Alc/backends/send.c @ 23:45dc4f76e548
adding send.c for cross compiling purposes
author | Robert McIntyre <rlm@mit.edu> |
---|---|
date | Fri, 18 Nov 2011 16:02:44 -0700 |
parents | |
children | f4c7260d397a |
comparison
equal
deleted
inserted
replaced
22:616215c81d23 | 23:45dc4f76e548 |
---|---|
1 | |
2 #include "config.h" | |
3 #include <stdlib.h> | |
4 #include "alMain.h" | |
5 #include "AL/al.h" | |
6 #include "AL/alc.h" | |
7 #include "alSource.h" | |
8 #include <jni.h> | |
9 | |
10 //////////////////// Summary | |
11 | |
12 struct send_data; | |
13 struct context_data; | |
14 | |
15 static void addContext(ALCdevice *, ALCcontext *); | |
16 static void syncContexts(ALCcontext *master, ALCcontext *slave); | |
17 static void syncSources(ALsource *master, ALsource *slave, | |
18 ALCcontext *masterCtx, ALCcontext *slaveCtx); | |
19 | |
20 static void syncSourcei(ALuint master, ALuint slave, | |
21 ALCcontext *masterCtx, ALCcontext *ctx2, ALenum param); | |
22 static void syncSourcef(ALuint master, ALuint slave, | |
23 ALCcontext *masterCtx, ALCcontext *ctx2, ALenum param); | |
24 static void syncSource3f(ALuint master, ALuint slave, | |
25 ALCcontext *masterCtx, ALCcontext *ctx2, ALenum param); | |
26 | |
27 static void swapInContext(ALCdevice *, struct context_data *); | |
28 static void saveContext(ALCdevice *, struct context_data *); | |
29 static void limitContext(ALCdevice *, ALCcontext *); | |
30 static void unLimitContext(ALCdevice *); | |
31 | |
32 static void init(ALCdevice *); | |
33 static void renderData(ALCdevice *, int samples); | |
34 | |
35 #define UNUSED(x) (void)(x) | |
36 //////////////////// State | |
37 | |
38 typedef struct context_data { | |
39 ALfloat ClickRemoval[MAXCHANNELS]; | |
40 ALfloat PendingClicks[MAXCHANNELS]; | |
41 ALvoid *renderBuffer; | |
42 ALCcontext *ctx; | |
43 } context_data; | |
44 | |
45 typedef struct send_data { | |
46 ALuint size; | |
47 context_data **contexts; | |
48 ALuint numContexts; | |
49 ALuint maxContexts; | |
50 } send_data; | |
51 //////////////////// Context Creation / Synchronization | |
52 | |
53 #define _MAKE_SYNC(NAME, INIT_EXPR, GET_EXPR, SET_EXPR) \ | |
54 void NAME (ALuint sourceID1, ALuint sourceID2, \ | |
55 ALCcontext *ctx1, ALCcontext *ctx2, \ | |
56 ALenum param){ \ | |
57 INIT_EXPR; \ | |
58 ALCcontext *current = alcGetCurrentContext(); \ | |
59 alcMakeContextCurrent(ctx1); \ | |
60 GET_EXPR; \ | |
61 alcMakeContextCurrent(ctx2); \ | |
62 SET_EXPR; \ | |
63 alcMakeContextCurrent(current); \ | |
64 } | |
65 | |
66 #define MAKE_SYNC(NAME, TYPE, GET, SET) \ | |
67 _MAKE_SYNC(NAME, \ | |
68 TYPE value, \ | |
69 GET(sourceID1, param, &value), \ | |
70 SET(sourceID2, param, value)) | |
71 | |
72 #define MAKE_SYNC3(NAME, TYPE, GET, SET) \ | |
73 _MAKE_SYNC(NAME, \ | |
74 TYPE value1; TYPE value2; TYPE value3;, \ | |
75 GET(sourceID1, param, &value1, &value2, &value3), \ | |
76 SET(sourceID2, param, value1, value2, value3)) | |
77 | |
78 MAKE_SYNC( syncSourcei, ALint, alGetSourcei, alSourcei); | |
79 MAKE_SYNC( syncSourcef, ALfloat, alGetSourcef, alSourcef); | |
80 MAKE_SYNC3(syncSource3i, ALint, alGetSource3i, alSource3i); | |
81 MAKE_SYNC3(syncSource3f, ALfloat, alGetSource3f, alSource3f); | |
82 | |
83 void syncSources(ALsource *masterSource, ALsource *slaveSource, | |
84 ALCcontext *masterCtx, ALCcontext *slaveCtx){ | |
85 ALuint master = masterSource->source; | |
86 ALuint slave = slaveSource->source; | |
87 ALCcontext *current = alcGetCurrentContext(); | |
88 | |
89 syncSourcef(master,slave,masterCtx,slaveCtx,AL_PITCH); | |
90 syncSourcef(master,slave,masterCtx,slaveCtx,AL_GAIN); | |
91 syncSourcef(master,slave,masterCtx,slaveCtx,AL_MAX_DISTANCE); | |
92 syncSourcef(master,slave,masterCtx,slaveCtx,AL_ROLLOFF_FACTOR); | |
93 syncSourcef(master,slave,masterCtx,slaveCtx,AL_REFERENCE_DISTANCE); | |
94 syncSourcef(master,slave,masterCtx,slaveCtx,AL_MIN_GAIN); | |
95 syncSourcef(master,slave,masterCtx,slaveCtx,AL_MAX_GAIN); | |
96 syncSourcef(master,slave,masterCtx,slaveCtx,AL_CONE_OUTER_GAIN); | |
97 syncSourcef(master,slave,masterCtx,slaveCtx,AL_CONE_INNER_ANGLE); | |
98 syncSourcef(master,slave,masterCtx,slaveCtx,AL_CONE_OUTER_ANGLE); | |
99 syncSourcef(master,slave,masterCtx,slaveCtx,AL_SEC_OFFSET); | |
100 syncSourcef(master,slave,masterCtx,slaveCtx,AL_SAMPLE_OFFSET); | |
101 syncSourcef(master,slave,masterCtx,slaveCtx,AL_BYTE_OFFSET); | |
102 | |
103 syncSource3f(master,slave,masterCtx,slaveCtx,AL_POSITION); | |
104 syncSource3f(master,slave,masterCtx,slaveCtx,AL_VELOCITY); | |
105 syncSource3f(master,slave,masterCtx,slaveCtx,AL_DIRECTION); | |
106 | |
107 syncSourcei(master,slave,masterCtx,slaveCtx,AL_SOURCE_RELATIVE); | |
108 syncSourcei(master,slave,masterCtx,slaveCtx,AL_LOOPING); | |
109 | |
110 alcMakeContextCurrent(masterCtx); | |
111 ALint source_type; | |
112 alGetSourcei(master, AL_SOURCE_TYPE, &source_type); | |
113 | |
114 // Only static sources are currently synchronized! | |
115 if (AL_STATIC == source_type){ | |
116 ALint master_buffer; | |
117 ALint slave_buffer; | |
118 alGetSourcei(master, AL_BUFFER, &master_buffer); | |
119 alcMakeContextCurrent(slaveCtx); | |
120 alGetSourcei(slave, AL_BUFFER, &slave_buffer); | |
121 if (master_buffer != slave_buffer){ | |
122 alSourcei(slave, AL_BUFFER, master_buffer); | |
123 } | |
124 } | |
125 | |
126 // Synchronize the state of the two sources. | |
127 alcMakeContextCurrent(masterCtx); | |
128 ALint masterState; | |
129 ALint slaveState; | |
130 | |
131 alGetSourcei(master, AL_SOURCE_STATE, &masterState); | |
132 alcMakeContextCurrent(slaveCtx); | |
133 alGetSourcei(slave, AL_SOURCE_STATE, &slaveState); | |
134 | |
135 if (masterState != slaveState){ | |
136 switch (masterState){ | |
137 case AL_INITIAL : alSourceRewind(slave); break; | |
138 case AL_PLAYING : alSourcePlay(slave); break; | |
139 case AL_PAUSED : alSourcePause(slave); break; | |
140 case AL_STOPPED : alSourceStop(slave); break; | |
141 } | |
142 } | |
143 // Restore whatever context was previously active. | |
144 alcMakeContextCurrent(current); | |
145 } | |
146 void syncContexts(ALCcontext *master, ALCcontext *slave){ | |
147 /* If there aren't sufficient sources in slave to mirror | |
148 the sources in master, create them. */ | |
149 ALCcontext *current = alcGetCurrentContext(); | |
150 | |
151 UIntMap *masterSourceMap = &(master->SourceMap); | |
152 UIntMap *slaveSourceMap = &(slave->SourceMap); | |
153 ALuint numMasterSources = masterSourceMap->size; | |
154 ALuint numSlaveSources = slaveSourceMap->size; | |
155 | |
156 alcMakeContextCurrent(slave); | |
157 if (numSlaveSources < numMasterSources){ | |
158 ALuint numMissingSources = numMasterSources - numSlaveSources; | |
159 ALuint newSources[numMissingSources]; | |
160 alGenSources(numMissingSources, newSources); | |
161 } | |
162 | |
163 /* Now, slave is guaranteed to have at least as many sources | |
164 as master. Sync each source from master to the corresponding | |
165 source in slave. */ | |
166 int i; | |
167 for(i = 0; i < masterSourceMap->size; i++){ | |
168 syncSources((ALsource*)masterSourceMap->array[i].value, | |
169 (ALsource*)slaveSourceMap->array[i].value, | |
170 master, slave); | |
171 } | |
172 alcMakeContextCurrent(current); | |
173 } | |
174 static void addContext(ALCdevice *Device, ALCcontext *context){ | |
175 send_data *data = (send_data*)Device->ExtraData; | |
176 // expand array if necessary | |
177 if (data->numContexts >= data->maxContexts){ | |
178 ALuint newMaxContexts = data->maxContexts*2 + 1; | |
179 data->contexts = realloc(data->contexts, newMaxContexts*sizeof(context_data)); | |
180 data->maxContexts = newMaxContexts; | |
181 } | |
182 // create context_data and add it to the main array | |
183 context_data *ctxData; | |
184 ctxData = (context_data*)calloc(1, sizeof(*ctxData)); | |
185 ctxData->renderBuffer = | |
186 malloc(BytesFromDevFmt(Device->FmtType) * | |
187 Device->NumChan * Device->UpdateSize); | |
188 ctxData->ctx = context; | |
189 | |
190 data->contexts[data->numContexts] = ctxData; | |
191 data->numContexts++; | |
192 } | |
193 //////////////////// Context Switching | |
194 | |
195 /* A device brings along with it two pieces of state | |
196 * which have to be swapped in and out with each context. | |
197 */ | |
198 static void swapInContext(ALCdevice *Device, context_data *ctxData){ | |
199 memcpy(Device->ClickRemoval, ctxData->ClickRemoval, sizeof(ALfloat)*MAXCHANNELS); | |
200 memcpy(Device->PendingClicks, ctxData->PendingClicks, sizeof(ALfloat)*MAXCHANNELS); | |
201 } | |
202 | |
203 static void saveContext(ALCdevice *Device, context_data *ctxData){ | |
204 memcpy(ctxData->ClickRemoval, Device->ClickRemoval, sizeof(ALfloat)*MAXCHANNELS); | |
205 memcpy(ctxData->PendingClicks, Device->PendingClicks, sizeof(ALfloat)*MAXCHANNELS); | |
206 } | |
207 | |
208 static ALCcontext **currentContext; | |
209 static ALuint currentNumContext; | |
210 | |
211 /* By default, all contexts are rendered at once for each call to aluMixData. | |
212 * This function uses the internals of the ALCdevice struct to temporally | |
213 * cause aluMixData to only render the chosen context. | |
214 */ | |
215 static void limitContext(ALCdevice *Device, ALCcontext *ctx){ | |
216 currentContext = Device->Contexts; | |
217 currentNumContext = Device->NumContexts; | |
218 Device->Contexts = &ctx; | |
219 Device->NumContexts = 1; | |
220 } | |
221 | |
222 static void unLimitContext(ALCdevice *Device){ | |
223 Device->Contexts = currentContext; | |
224 Device->NumContexts = currentNumContext; | |
225 } | |
226 //////////////////// Main Device Loop | |
227 | |
228 /* Establish the LWJGL context as the master context, which will | |
229 * be synchronized to all the slave contexts | |
230 */ | |
231 static void init(ALCdevice *Device){ | |
232 ALCcontext *masterContext = alcGetCurrentContext(); | |
233 addContext(Device, masterContext); | |
234 } | |
235 | |
236 | |
237 static void renderData(ALCdevice *Device, int samples){ | |
238 if(!Device->Connected){return;} | |
239 send_data *data = (send_data*)Device->ExtraData; | |
240 ALCcontext *current = alcGetCurrentContext(); | |
241 | |
242 ALuint i; | |
243 for (i = 1; i < data->numContexts; i++){ | |
244 syncContexts(data->contexts[0]->ctx , data->contexts[i]->ctx); | |
245 } | |
246 | |
247 if ((uint) samples > Device->UpdateSize){ | |
248 printf("exceeding internal buffer size; dropping samples\n"); | |
249 printf("requested %d; available %d\n", samples, Device->UpdateSize); | |
250 samples = (int) Device->UpdateSize; | |
251 } | |
252 | |
253 for (i = 0; i < data->numContexts; i++){ | |
254 context_data *ctxData = data->contexts[i]; | |
255 ALCcontext *ctx = ctxData->ctx; | |
256 alcMakeContextCurrent(ctx); | |
257 limitContext(Device, ctx); | |
258 swapInContext(Device, ctxData); | |
259 aluMixData(Device, ctxData->renderBuffer, samples); | |
260 saveContext(Device, ctxData); | |
261 unLimitContext(Device); | |
262 } | |
263 alcMakeContextCurrent(current); | |
264 } | |
265 //////////////////// JNI Methods | |
266 | |
267 #include "com_aurellem_send_AudioSend.h" | |
268 | |
269 /* | |
270 * Class: com_aurellem_send_AudioSend | |
271 * Method: nstep | |
272 * Signature: (JI)V | |
273 */ | |
274 JNIEXPORT void JNICALL Java_com_aurellem_send_AudioSend_nstep | |
275 (JNIEnv *env, jclass clazz, jlong device, jint samples){ | |
276 UNUSED(env);UNUSED(clazz);UNUSED(device); | |
277 renderData((ALCdevice*)((intptr_t)device), samples); | |
278 } | |
279 /* | |
280 * Class: com_aurellem_send_AudioSend | |
281 * Method: ngetSamples | |
282 * Signature: (JLjava/nio/ByteBuffer;III)V | |
283 */ | |
284 JNIEXPORT void JNICALL Java_com_aurellem_send_AudioSend_ngetSamples | |
285 (JNIEnv *env, jclass clazz, jlong device, jobject buffer, jint position, | |
286 jint samples, jint n){ | |
287 UNUSED(clazz); | |
288 | |
289 ALvoid *buffer_address = | |
290 ((ALbyte *)(((char*)(*env)->GetDirectBufferAddress(env, buffer)) + position)); | |
291 ALCdevice *recorder = (ALCdevice*) ((intptr_t)device); | |
292 send_data *data = (send_data*)recorder->ExtraData; | |
293 if ((ALuint)n > data->numContexts){return;} | |
294 memcpy(buffer_address, data->contexts[n]->renderBuffer, | |
295 BytesFromDevFmt(recorder->FmtType) * recorder->NumChan * samples); | |
296 } | |
297 /* | |
298 * Class: com_aurellem_send_AudioSend | |
299 * Method: naddListener | |
300 * Signature: (J)V | |
301 */ | |
302 JNIEXPORT void JNICALL Java_com_aurellem_send_AudioSend_naddListener | |
303 (JNIEnv *env, jclass clazz, jlong device){ | |
304 UNUSED(env); UNUSED(clazz); | |
305 //printf("creating new context via naddListener\n"); | |
306 ALCdevice *Device = (ALCdevice*) ((intptr_t)device); | |
307 ALCcontext *new = alcCreateContext(Device, NULL); | |
308 addContext(Device, new); | |
309 } | |
310 | |
311 /* | |
312 * Class: com_aurellem_send_AudioSend | |
313 * Method: nsetNthListener3f | |
314 * Signature: (IFFFJI)V | |
315 */ | |
316 JNIEXPORT void JNICALL Java_com_aurellem_send_AudioSend_nsetNthListener3f | |
317 (JNIEnv *env, jclass clazz, jint param, | |
318 jfloat v1, jfloat v2, jfloat v3, jlong device, jint contextNum){ | |
319 UNUSED(env);UNUSED(clazz); | |
320 | |
321 ALCdevice *Device = (ALCdevice*) ((intptr_t)device); | |
322 send_data *data = (send_data*)Device->ExtraData; | |
323 | |
324 ALCcontext *current = alcGetCurrentContext(); | |
325 if ((ALuint)contextNum > data->numContexts){return;} | |
326 alcMakeContextCurrent(data->contexts[contextNum]->ctx); | |
327 alListener3f(param, v1, v2, v3); | |
328 alcMakeContextCurrent(current); | |
329 } | |
330 | |
331 /* | |
332 * Class: com_aurellem_send_AudioSend | |
333 * Method: nsetNthListenerf | |
334 * Signature: (IFJI)V | |
335 */ | |
336 JNIEXPORT void JNICALL Java_com_aurellem_send_AudioSend_nsetNthListenerf | |
337 (JNIEnv *env, jclass clazz, jint param, jfloat v1, jlong device, | |
338 jint contextNum){ | |
339 | |
340 UNUSED(env);UNUSED(clazz); | |
341 | |
342 ALCdevice *Device = (ALCdevice*) ((intptr_t)device); | |
343 send_data *data = (send_data*)Device->ExtraData; | |
344 | |
345 ALCcontext *current = alcGetCurrentContext(); | |
346 if ((ALuint)contextNum > data->numContexts){return;} | |
347 alcMakeContextCurrent(data->contexts[contextNum]->ctx); | |
348 alListenerf(param, v1); | |
349 alcMakeContextCurrent(current); | |
350 } | |
351 /* | |
352 * Class: com_aurellem_send_AudioSend | |
353 * Method: ninitDevice | |
354 * Signature: (J)V | |
355 */ | |
356 JNIEXPORT void JNICALL Java_com_aurellem_send_AudioSend_ninitDevice | |
357 (JNIEnv *env, jclass clazz, jlong device){ | |
358 UNUSED(env);UNUSED(clazz); | |
359 ALCdevice *Device = (ALCdevice*) ((intptr_t)device); | |
360 init(Device); | |
361 } | |
362 | |
363 /* | |
364 * Class: com_aurellem_send_AudioSend | |
365 * Method: ngetAudioFormat | |
366 * Signature: (J)Ljavax/sound/sampled/AudioFormat; | |
367 */ | |
368 JNIEXPORT jobject JNICALL Java_com_aurellem_send_AudioSend_ngetAudioFormat | |
369 (JNIEnv *env, jclass clazz, jlong device){ | |
370 UNUSED(clazz); | |
371 jclass AudioFormatClass = | |
372 (*env)->FindClass(env, "javax/sound/sampled/AudioFormat"); | |
373 jmethodID AudioFormatConstructor = | |
374 (*env)->GetMethodID(env, AudioFormatClass, "<init>", "(FIIZZ)V"); | |
375 | |
376 ALCdevice *Device = (ALCdevice*) ((intptr_t)device); | |
377 int isSigned; | |
378 switch (Device->FmtType) | |
379 { | |
380 case DevFmtUByte: | |
381 case DevFmtUShort: isSigned = 0; break; | |
382 default : isSigned = 1; | |
383 } | |
384 float frequency = Device->Frequency; | |
385 int bitsPerFrame = (8 * BytesFromDevFmt(Device->FmtType)); | |
386 int channels = Device->NumChan; | |
387 jobject format = (*env)-> | |
388 NewObject( | |
389 env,AudioFormatClass,AudioFormatConstructor, | |
390 frequency, | |
391 bitsPerFrame, | |
392 channels, | |
393 isSigned, | |
394 0); | |
395 return format; | |
396 } | |
397 //////////////////// Device Initialization / Management | |
398 | |
399 static const ALCchar sendDevice[] = "Multiple Audio Send"; | |
400 | |
401 static ALCboolean send_open_playback(ALCdevice *device, | |
402 const ALCchar *deviceName) | |
403 { | |
404 send_data *data; | |
405 // stop any buffering for stdout, so that I can | |
406 // see the printf statements in my terminal immediately | |
407 setbuf(stdout, NULL); | |
408 | |
409 if(!deviceName) | |
410 deviceName = sendDevice; | |
411 else if(strcmp(deviceName, sendDevice) != 0) | |
412 return ALC_FALSE; | |
413 data = (send_data*)calloc(1, sizeof(*data)); | |
414 device->szDeviceName = strdup(deviceName); | |
415 device->ExtraData = data; | |
416 return ALC_TRUE; | |
417 } | |
418 | |
419 static void send_close_playback(ALCdevice *device) | |
420 { | |
421 send_data *data = (send_data*)device->ExtraData; | |
422 alcMakeContextCurrent(NULL); | |
423 ALuint i; | |
424 // Destroy all slave contexts. LWJGL will take care of | |
425 // its own context. | |
426 for (i = 1; i < data->numContexts; i++){ | |
427 context_data *ctxData = data->contexts[i]; | |
428 alcDestroyContext(ctxData->ctx); | |
429 free(ctxData->renderBuffer); | |
430 free(ctxData); | |
431 } | |
432 free(data); | |
433 device->ExtraData = NULL; | |
434 } | |
435 | |
436 static ALCboolean send_reset_playback(ALCdevice *device) | |
437 { | |
438 SetDefaultWFXChannelOrder(device); | |
439 return ALC_TRUE; | |
440 } | |
441 | |
442 static void send_stop_playback(ALCdevice *Device){ | |
443 UNUSED(Device); | |
444 } | |
445 | |
446 static const BackendFuncs send_funcs = { | |
447 send_open_playback, | |
448 send_close_playback, | |
449 send_reset_playback, | |
450 send_stop_playback, | |
451 NULL, | |
452 NULL, /* These would be filled with functions to */ | |
453 NULL, /* handle capturing audio if we we into that */ | |
454 NULL, /* sort of thing... */ | |
455 NULL, | |
456 NULL | |
457 }; | |
458 | |
459 ALCboolean alc_send_init(BackendFuncs *func_list){ | |
460 *func_list = send_funcs; | |
461 return ALC_TRUE; | |
462 } | |
463 | |
464 void alc_send_deinit(void){} | |
465 | |
466 void alc_send_probe(enum DevProbe type) | |
467 { | |
468 switch(type) | |
469 { | |
470 case DEVICE_PROBE: | |
471 AppendDeviceList(sendDevice); | |
472 break; | |
473 case ALL_DEVICE_PROBE: | |
474 AppendAllDeviceList(sendDevice); | |
475 break; | |
476 case CAPTURE_DEVICE_PROBE: | |
477 break; | |
478 } | |
479 } |