Mercurial > audio-send

comparison OpenAL32/alListener.c @ 0:f9476ff7637e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial forking of open-al to create multiple listeners
author Robert McIntyre <rlm@mit.edu>
date Tue, 25 Oct 2011 13:02:31 -0700
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f9476ff7637e
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2000 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library 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 GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include "alMain.h"
24 #include "AL/alc.h"
25 #include "alError.h"
26 #include "alListener.h"
27 #include "alSource.h"
28
29 AL_API ALvoid AL_APIENTRY alListenerf(ALenum eParam, ALfloat flValue)
30 {
31 ALCcontext *pContext;
32
33 pContext = GetLockedContext();
34 if(!pContext) return;
35
36 switch(eParam)
37 {
38 case AL_GAIN:
39 if(flValue >= 0.0f && isfinite(flValue))
40 {
41 pContext->Listener.Gain = flValue;
42 pContext->UpdateSources = AL_TRUE;
43 }
44 else
45 alSetError(pContext, AL_INVALID_VALUE);
46 break;
47
48 case AL_METERS_PER_UNIT:
49 if(flValue > 0.0f && isfinite(flValue))
50 {
51 pContext->Listener.MetersPerUnit = flValue;
52 pContext->UpdateSources = AL_TRUE;
53 }
54 else
55 alSetError(pContext, AL_INVALID_VALUE);
56 break;
57
58 default:
59 alSetError(pContext, AL_INVALID_ENUM);
60 break;
61 }
62
63 UnlockContext(pContext);
64 }
65
66
67 AL_API ALvoid AL_APIENTRY alListener3f(ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
68 {
69 ALCcontext *pContext;
70
71 pContext = GetLockedContext();
72 if(!pContext) return;
73
74 switch(eParam)
75 {
76 case AL_POSITION:
77 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
78 {
79 pContext->Listener.Position[0] = flValue1;
80 pContext->Listener.Position[1] = flValue2;
81 pContext->Listener.Position[2] = flValue3;
82 pContext->UpdateSources = AL_TRUE;
83 }
84 else
85 alSetError(pContext, AL_INVALID_VALUE);
86 break;
87
88 case AL_VELOCITY:
89 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
90 {
91 pContext->Listener.Velocity[0] = flValue1;
92 pContext->Listener.Velocity[1] = flValue2;
93 pContext->Listener.Velocity[2] = flValue3;
94 pContext->UpdateSources = AL_TRUE;
95 }
96 else
97 alSetError(pContext, AL_INVALID_VALUE);
98 break;
99
100 default:
101 alSetError(pContext, AL_INVALID_ENUM);
102 break;
103 }
104
105 UnlockContext(pContext);
106 }
107
108
109 AL_API ALvoid AL_APIENTRY alListenerfv(ALenum eParam, const ALfloat *pflValues)
110 {
111 ALCcontext *pContext;
112
113 if(pflValues)
114 {
115 switch(eParam)
116 {
117 case AL_GAIN:
118 case AL_METERS_PER_UNIT:
119 alListenerf(eParam, pflValues[0]);
120 return;
121
122 case AL_POSITION:
123 case AL_VELOCITY:
124 alListener3f(eParam, pflValues[0], pflValues[1], pflValues[2]);
125 return;
126 }
127 }
128
129 pContext = GetLockedContext();
130 if(!pContext) return;
131
132 if(pflValues)
133 {
134 switch(eParam)
135 {
136 case AL_ORIENTATION:
137 if(isfinite(pflValues[0]) && isfinite(pflValues[1]) &&
138 isfinite(pflValues[2]) && isfinite(pflValues[3]) &&
139 isfinite(pflValues[4]) && isfinite(pflValues[5]))
140 {
141 // AT then UP
142 pContext->Listener.Forward[0] = pflValues[0];
143 pContext->Listener.Forward[1] = pflValues[1];
144 pContext->Listener.Forward[2] = pflValues[2];
145 pContext->Listener.Up[0] = pflValues[3];
146 pContext->Listener.Up[1] = pflValues[4];
147 pContext->Listener.Up[2] = pflValues[5];
148 pContext->UpdateSources = AL_TRUE;
149 }
150 else
151 alSetError(pContext, AL_INVALID_VALUE);
152 break;
153
154 default:
155 alSetError(pContext, AL_INVALID_ENUM);
156 break;
157 }
158 }
159 else
160 alSetError(pContext, AL_INVALID_VALUE);
161
162 UnlockContext(pContext);
163 }
164
165
166 AL_API ALvoid AL_APIENTRY alListeneri(ALenum eParam, ALint lValue)
167 {
168 ALCcontext *pContext;
169
170 (void)lValue;
171
172 pContext = GetLockedContext();
173 if(!pContext) return;
174
175 switch(eParam)
176 {
177 default:
178 alSetError(pContext, AL_INVALID_ENUM);
179 break;
180 }
181
182 UnlockContext(pContext);
183 }
184
185
186 AL_API void AL_APIENTRY alListener3i(ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
187 {
188 ALCcontext *pContext;
189
190 switch(eParam)
191 {
192 case AL_POSITION:
193 case AL_VELOCITY:
194 alListener3f(eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
195 return;
196 }
197
198 pContext = GetLockedContext();
199 if(!pContext) return;
200
201 switch(eParam)
202 {
203 default:
204 alSetError(pContext, AL_INVALID_ENUM);
205 break;
206 }
207
208 UnlockContext(pContext);
209 }
210
211
212 AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
213 {
214 ALCcontext *pContext;
215 ALfloat flValues[6];
216
217 if(plValues)
218 {
219 switch(eParam)
220 {
221 case AL_POSITION:
222 case AL_VELOCITY:
223 alListener3f(eParam, plValues[0], plValues[1], plValues[2]);
224 return;
225
226 case AL_ORIENTATION:
227 flValues[0] = (ALfloat)plValues[0];
228 flValues[1] = (ALfloat)plValues[1];
229 flValues[2] = (ALfloat)plValues[2];
230 flValues[3] = (ALfloat)plValues[3];
231 flValues[4] = (ALfloat)plValues[4];
232 flValues[5] = (ALfloat)plValues[5];
233 alListenerfv(eParam, flValues);
234 return;
235 }
236 }
237
238 pContext = GetLockedContext();
239 if(!pContext) return;
240
241 if(plValues)
242 {
243 switch(eParam)
244 {
245 default:
246 alSetError(pContext, AL_INVALID_ENUM);
247 break;
248 }
249 }
250 else
251 alSetError(pContext, AL_INVALID_VALUE);
252
253 UnlockContext(pContext);
254 }
255
256
257 AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum eParam, ALfloat *pflValue)
258 {
259 ALCcontext *pContext;
260
261 pContext = GetLockedContext();
262 if(!pContext) return;
263
264 if(pflValue)
265 {
266 switch(eParam)
267 {
268 case AL_GAIN:
269 *pflValue = pContext->Listener.Gain;
270 break;
271
272 case AL_METERS_PER_UNIT:
273 *pflValue = pContext->Listener.MetersPerUnit;
274 break;
275
276 default:
277 alSetError(pContext, AL_INVALID_ENUM);
278 break;
279 }
280 }
281 else
282 alSetError(pContext, AL_INVALID_VALUE);
283
284 UnlockContext(pContext);
285 }
286
287
288 AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum eParam, ALfloat *pflValue1, ALfloat *pflValue2, ALfloat *pflValue3)
289 {
290 ALCcontext *pContext;
291
292 pContext = GetLockedContext();
293 if(!pContext) return;
294
295 if(pflValue1 && pflValue2 && pflValue3)
296 {
297 switch(eParam)
298 {
299 case AL_POSITION:
300 *pflValue1 = pContext->Listener.Position[0];
301 *pflValue2 = pContext->Listener.Position[1];
302 *pflValue3 = pContext->Listener.Position[2];
303 break;
304
305 case AL_VELOCITY:
306 *pflValue1 = pContext->Listener.Velocity[0];
307 *pflValue2 = pContext->Listener.Velocity[1];
308 *pflValue3 = pContext->Listener.Velocity[2];
309 break;
310
311 default:
312 alSetError(pContext, AL_INVALID_ENUM);
313 break;
314 }
315 }
316 else
317 alSetError(pContext, AL_INVALID_VALUE);
318
319 UnlockContext(pContext);
320 }
321
322
323 AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum eParam, ALfloat *pflValues)
324 {
325 ALCcontext *pContext;
326
327 switch(eParam)
328 {
329 case AL_GAIN:
330 case AL_METERS_PER_UNIT:
331 alGetListenerf(eParam, pflValues);
332 return;
333
334 case AL_POSITION:
335 case AL_VELOCITY:
336 alGetListener3f(eParam, pflValues+0, pflValues+1, pflValues+2);
337 return;
338 }
339
340 pContext = GetLockedContext();
341 if(!pContext) return;
342
343 if(pflValues)
344 {
345 switch(eParam)
346 {
347 case AL_ORIENTATION:
348 // AT then UP
349 pflValues[0] = pContext->Listener.Forward[0];
350 pflValues[1] = pContext->Listener.Forward[1];
351 pflValues[2] = pContext->Listener.Forward[2];
352 pflValues[3] = pContext->Listener.Up[0];
353 pflValues[4] = pContext->Listener.Up[1];
354 pflValues[5] = pContext->Listener.Up[2];
355 break;
356
357 default:
358 alSetError(pContext, AL_INVALID_ENUM);
359 break;
360 }
361 }
362 else
363 alSetError(pContext, AL_INVALID_VALUE);
364
365 UnlockContext(pContext);
366 }
367
368
369 AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
370 {
371 ALCcontext *pContext;
372
373 pContext = GetLockedContext();
374 if(!pContext) return;
375
376 if(plValue)
377 {
378 switch(eParam)
379 {
380 default:
381 alSetError(pContext, AL_INVALID_ENUM);
382 break;
383 }
384 }
385 else
386 alSetError(pContext, AL_INVALID_VALUE);
387
388 UnlockContext(pContext);
389 }
390
391
392 AL_API void AL_APIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3)
393 {
394 ALCcontext *pContext;
395
396 pContext = GetLockedContext();
397 if(!pContext) return;
398
399 if(plValue1 && plValue2 && plValue3)
400 {
401 switch (eParam)
402 {
403 case AL_POSITION:
404 *plValue1 = (ALint)pContext->Listener.Position[0];
405 *plValue2 = (ALint)pContext->Listener.Position[1];
406 *plValue3 = (ALint)pContext->Listener.Position[2];
407 break;
408
409 case AL_VELOCITY:
410 *plValue1 = (ALint)pContext->Listener.Velocity[0];
411 *plValue2 = (ALint)pContext->Listener.Velocity[1];
412 *plValue3 = (ALint)pContext->Listener.Velocity[2];
413 break;
414
415 default:
416 alSetError(pContext, AL_INVALID_ENUM);
417 break;
418 }
419 }
420 else
421 alSetError(pContext, AL_INVALID_VALUE);
422
423 UnlockContext(pContext);
424 }
425
426
427 AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
428 {
429 ALCcontext *pContext;
430
431 switch(eParam)
432 {
433 case AL_POSITION:
434 case AL_VELOCITY:
435 alGetListener3i(eParam, plValues+0, plValues+1, plValues+2);
436 return;
437 }
438
439 pContext = GetLockedContext();
440 if(!pContext) return;
441
442 if(plValues)
443 {
444 switch(eParam)
445 {
446 case AL_ORIENTATION:
447 // AT then UP
448 plValues[0] = (ALint)pContext->Listener.Forward[0];
449 plValues[1] = (ALint)pContext->Listener.Forward[1];
450 plValues[2] = (ALint)pContext->Listener.Forward[2];
451 plValues[3] = (ALint)pContext->Listener.Up[0];
452 plValues[4] = (ALint)pContext->Listener.Up[1];
453 plValues[5] = (ALint)pContext->Listener.Up[2];
454 break;
455
456 default:
457 alSetError(pContext, AL_INVALID_ENUM);
458 break;
459 }
460 }
461 else
462 alSetError(pContext, AL_INVALID_VALUE);
463
464 UnlockContext(pContext);
465 }