?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Minor corrections to the hrtf.txt
[openal-soft.git] / OpenAL32 / alSource.c
blobaf03985999958ef38afec1f232205f62a11b8135
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 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 <stdlib.h>
24 #include <math.h>
25 #include <float.h>
26 #include "alMain.h"
27 #include "AL/al.h"
28 #include "AL/alc.h"
29 #include "alError.h"
30 #include "alSource.h"
31 #include "alBuffer.h"
32 #include "alThunk.h"
33 #include "alAuxEffectSlot.h"
34
35
36 enum Resampler DefaultResampler = LinearResampler;
37 const ALsizei ResamplerPadding[ResamplerMax] = {
38 0, /* Point */
39 1, /* Linear */
40 2, /* Cubic */
41 };
42 const ALsizei ResamplerPrePadding[ResamplerMax] = {
43 0, /* Point */
44 0, /* Linear */
45 1, /* Cubic */
46 };
47
48
49 static ALvoid InitSourceParams(ALsource *Source);
50 static ALvoid GetSourceOffset(ALsource *Source, ALenum eName, ALdouble *Offsets, ALdouble updateLen);
51 static ALint GetSampleOffset(ALsource *Source);
52
53
54 AL_API ALvoid AL_APIENTRY alGenSources(ALsizei n,ALuint *sources)
55 {
56 ALCcontext *Context;
57
58 Context = GetContextRef();
59 if(!Context) return;
60
61 if(n < 0 || IsBadWritePtr((void*)sources, n * sizeof(ALuint)))
62 alSetError(Context, AL_INVALID_VALUE);
63 else
64 {
65 ALenum err;
66 ALsizei i;
67
68 // Add additional sources to the list
69 i = 0;
70 while(i < n)
71 {
72 ALsource *source = calloc(1, sizeof(ALsource));
73 if(!source)
74 {
75 alSetError(Context, AL_OUT_OF_MEMORY);
76 alDeleteSources(i, sources);
77 break;
78 }
79 InitSourceParams(source);
80
81 err = NewThunkEntry(&source->source);
82 if(err == AL_NO_ERROR)
83 err = InsertUIntMapEntry(&Context->SourceMap, source->source, source);
84 if(err != AL_NO_ERROR)
85 {
86 FreeThunkEntry(source->source);
87 memset(source, 0, sizeof(ALsource));
88 free(source);
89
90 alSetError(Context, err);
91 alDeleteSources(i, sources);
92 break;
93 }
94
95 sources[i++] = source->source;
96 }
97 }
98
99 ALCcontext_DecRef(Context);
100 }
101
102
103 AL_API ALvoid AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
104 {
105 ALCcontext *Context;
106 ALsource *Source;
107 ALsizei i, j;
108 ALbufferlistitem *BufferList;
109
110 Context = GetContextRef();
111 if(!Context) return;
112
113 if(n < 0)
114 alSetError(Context, AL_INVALID_VALUE);
115 else
116 {
117 // Check that all Sources are valid (and can therefore be deleted)
118 for(i = 0;i < n;i++)
119 {
120 if(LookupSource(Context, sources[i]) == NULL)
121 {
122 alSetError(Context, AL_INVALID_NAME);
123 n = 0;
124 break;
125 }
126 }
127
128 // All Sources are valid, and can be deleted
129 for(i = 0;i < n;i++)
130 {
131 ALsource **srclist, **srclistend;
132
133 // Remove Source from list of Sources
134 if((Source=RemoveSource(Context, sources[i])) == NULL)
135 continue;
136
137 FreeThunkEntry(Source->source);
138
139 LockContext(Context);
140 srclist = Context->ActiveSources;
141 srclistend = srclist + Context->ActiveSourceCount;
142 while(srclist != srclistend)
143 {
144 if(*srclist == Source)
145 {
146 Context->ActiveSourceCount--;
147 *srclist = *(--srclistend);
148 break;
149 }
150 srclist++;
151 }
152 UnlockContext(Context);
153
154 // For each buffer in the source's queue...
155 while(Source->queue != NULL)
156 {
157 BufferList = Source->queue;
158 Source->queue = BufferList->next;
159
160 if(BufferList->buffer != NULL)
161 DecrementRef(&BufferList->buffer->ref);
162 free(BufferList);
163 }
164
165 for(j = 0;j < MAX_SENDS;++j)
166 {
167 if(Source->Send[j].Slot)
168 DecrementRef(&Source->Send[j].Slot->ref);
169 Source->Send[j].Slot = NULL;
170 }
171
172 memset(Source,0,sizeof(ALsource));
173 free(Source);
174 }
175 }
176
177 ALCcontext_DecRef(Context);
178 }
179
180
181 AL_API ALboolean AL_APIENTRY alIsSource(ALuint source)
182 {
183 ALCcontext *Context;
184 ALboolean result;
185
186 Context = GetContextRef();
187 if(!Context) return AL_FALSE;
188
189 result = (LookupSource(Context, source) ? AL_TRUE : AL_FALSE);
190
191 ALCcontext_DecRef(Context);
192
193 return result;
194 }
195
196
197 AL_API ALvoid AL_APIENTRY alSourcef(ALuint source, ALenum eParam, ALfloat flValue)
198 {
199 ALCcontext *pContext;
200 ALsource *Source;
201
202 pContext = GetContextRef();
203 if(!pContext) return;
204
205 if((Source=LookupSource(pContext, source)) != NULL)
206 {
207 switch(eParam)
208 {
209 case AL_PITCH:
210 if(flValue >= 0.0f)
211 {
212 Source->flPitch = flValue;
213 Source->NeedsUpdate = AL_TRUE;
214 }
215 else
216 alSetError(pContext, AL_INVALID_VALUE);
217 break;
218
219 case AL_CONE_INNER_ANGLE:
220 if(flValue >= 0.0f && flValue <= 360.0f)
221 {
222 Source->flInnerAngle = flValue;
223 Source->NeedsUpdate = AL_TRUE;
224 }
225 else
226 alSetError(pContext, AL_INVALID_VALUE);
227 break;
228
229 case AL_CONE_OUTER_ANGLE:
230 if(flValue >= 0.0f && flValue <= 360.0f)
231 {
232 Source->flOuterAngle = flValue;
233 Source->NeedsUpdate = AL_TRUE;
234 }
235 else
236 alSetError(pContext, AL_INVALID_VALUE);
237 break;
238
239 case AL_GAIN:
240 if(flValue >= 0.0f)
241 {
242 Source->flGain = flValue;
243 Source->NeedsUpdate = AL_TRUE;
244 }
245 else
246 alSetError(pContext, AL_INVALID_VALUE);
247 break;
248
249 case AL_MAX_DISTANCE:
250 if(flValue >= 0.0f)
251 {
252 Source->flMaxDistance = flValue;
253 Source->NeedsUpdate = AL_TRUE;
254 }
255 else
256 alSetError(pContext, AL_INVALID_VALUE);
257 break;
258
259 case AL_ROLLOFF_FACTOR:
260 if(flValue >= 0.0f)
261 {
262 Source->flRollOffFactor = flValue;
263 Source->NeedsUpdate = AL_TRUE;
264 }
265 else
266 alSetError(pContext, AL_INVALID_VALUE);
267 break;
268
269 case AL_REFERENCE_DISTANCE:
270 if(flValue >= 0.0f)
271 {
272 Source->flRefDistance = flValue;
273 Source->NeedsUpdate = AL_TRUE;
274 }
275 else
276 alSetError(pContext, AL_INVALID_VALUE);
277 break;
278
279 case AL_MIN_GAIN:
280 if(flValue >= 0.0f && flValue <= 1.0f)
281 {
282 Source->flMinGain = flValue;
283 Source->NeedsUpdate = AL_TRUE;
284 }
285 else
286 alSetError(pContext, AL_INVALID_VALUE);
287 break;
288
289 case AL_MAX_GAIN:
290 if(flValue >= 0.0f && flValue <= 1.0f)
291 {
292 Source->flMaxGain = flValue;
293 Source->NeedsUpdate = AL_TRUE;
294 }
295 else
296 alSetError(pContext, AL_INVALID_VALUE);
297 break;
298
299 case AL_CONE_OUTER_GAIN:
300 if(flValue >= 0.0f && flValue <= 1.0f)
301 {
302 Source->flOuterGain = flValue;
303 Source->NeedsUpdate = AL_TRUE;
304 }
305 else
306 alSetError(pContext, AL_INVALID_VALUE);
307 break;
308
309 case AL_CONE_OUTER_GAINHF:
310 if(flValue >= 0.0f && flValue <= 1.0f)
311 {
312 Source->OuterGainHF = flValue;
313 Source->NeedsUpdate = AL_TRUE;
314 }
315 else
316 alSetError(pContext, AL_INVALID_VALUE);
317 break;
318
319 case AL_AIR_ABSORPTION_FACTOR:
320 if(flValue >= 0.0f && flValue <= 10.0f)
321 {
322 Source->AirAbsorptionFactor = flValue;
323 Source->NeedsUpdate = AL_TRUE;
324 }
325 else
326 alSetError(pContext, AL_INVALID_VALUE);
327 break;
328
329 case AL_ROOM_ROLLOFF_FACTOR:
330 if(flValue >= 0.0f && flValue <= 10.0f)
331 {
332 Source->RoomRolloffFactor = flValue;
333 Source->NeedsUpdate = AL_TRUE;
334 }
335 else
336 alSetError(pContext, AL_INVALID_VALUE);
337 break;
338
339 case AL_DOPPLER_FACTOR:
340 if(flValue >= 0.0f && flValue <= 1.0f)
341 {
342 Source->DopplerFactor = flValue;
343 Source->NeedsUpdate = AL_TRUE;
344 }
345 else
346 alSetError(pContext, AL_INVALID_VALUE);
347 break;
348
349 case AL_SEC_OFFSET:
350 case AL_SAMPLE_OFFSET:
351 case AL_BYTE_OFFSET:
352 if(flValue >= 0.0f)
353 {
354 LockContext(pContext);
355 Source->lOffsetType = eParam;
356
357 // Store Offset (convert Seconds into Milliseconds)
358 if(eParam == AL_SEC_OFFSET)
359 Source->lOffset = (ALint)(flValue * 1000.0f);
360 else
361 Source->lOffset = (ALint)flValue;
362
363 if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
364 !pContext->DeferUpdates)
365 {
366 if(ApplyOffset(Source) == AL_FALSE)
367 alSetError(pContext, AL_INVALID_VALUE);
368 }
369 UnlockContext(pContext);
370 }
371 else
372 alSetError(pContext, AL_INVALID_VALUE);
373 break;
374
375 default:
376 alSetError(pContext, AL_INVALID_ENUM);
377 break;
378 }
379 }
380 else
381 {
382 // Invalid Source Name
383 alSetError(pContext, AL_INVALID_NAME);
384 }
385
386 ALCcontext_DecRef(pContext);
387 }
388
389
390 AL_API ALvoid AL_APIENTRY alSource3f(ALuint source, ALenum eParam, ALfloat flValue1,ALfloat flValue2,ALfloat flValue3)
391 {
392 ALCcontext *pContext;
393 ALsource *Source;
394
395 pContext = GetContextRef();
396 if(!pContext) return;
397
398 if((Source=LookupSource(pContext, source)) != NULL)
399 {
400 switch(eParam)
401 {
402 case AL_POSITION:
403 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
404 {
405 LockContext(pContext);
406 Source->vPosition[0] = flValue1;
407 Source->vPosition[1] = flValue2;
408 Source->vPosition[2] = flValue3;
409 UnlockContext(pContext);
410 Source->NeedsUpdate = AL_TRUE;
411 }
412 else
413 alSetError(pContext, AL_INVALID_VALUE);
414 break;
415
416 case AL_VELOCITY:
417 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
418 {
419 LockContext(pContext);
420 Source->vVelocity[0] = flValue1;
421 Source->vVelocity[1] = flValue2;
422 Source->vVelocity[2] = flValue3;
423 UnlockContext(pContext);
424 Source->NeedsUpdate = AL_TRUE;
425 }
426 else
427 alSetError(pContext, AL_INVALID_VALUE);
428 break;
429
430 case AL_DIRECTION:
431 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
432 {
433 LockContext(pContext);
434 Source->vOrientation[0] = flValue1;
435 Source->vOrientation[1] = flValue2;
436 Source->vOrientation[2] = flValue3;
437 UnlockContext(pContext);
438 Source->NeedsUpdate = AL_TRUE;
439 }
440 else
441 alSetError(pContext, AL_INVALID_VALUE);
442 break;
443
444 default:
445 alSetError(pContext, AL_INVALID_ENUM);
446 break;
447 }
448 }
449 else
450 alSetError(pContext, AL_INVALID_NAME);
451
452 ALCcontext_DecRef(pContext);
453 }
454
455
456 AL_API ALvoid AL_APIENTRY alSourcefv(ALuint source, ALenum eParam, const ALfloat *pflValues)
457 {
458 ALCcontext *pContext;
459
460 if(pflValues)
461 {
462 switch(eParam)
463 {
464 case AL_PITCH:
465 case AL_CONE_INNER_ANGLE:
466 case AL_CONE_OUTER_ANGLE:
467 case AL_GAIN:
468 case AL_MAX_DISTANCE:
469 case AL_ROLLOFF_FACTOR:
470 case AL_REFERENCE_DISTANCE:
471 case AL_MIN_GAIN:
472 case AL_MAX_GAIN:
473 case AL_CONE_OUTER_GAIN:
474 case AL_CONE_OUTER_GAINHF:
475 case AL_SEC_OFFSET:
476 case AL_SAMPLE_OFFSET:
477 case AL_BYTE_OFFSET:
478 case AL_AIR_ABSORPTION_FACTOR:
479 case AL_ROOM_ROLLOFF_FACTOR:
480 alSourcef(source, eParam, pflValues[0]);
481 return;
482
483 case AL_POSITION:
484 case AL_VELOCITY:
485 case AL_DIRECTION:
486 alSource3f(source, eParam, pflValues[0], pflValues[1], pflValues[2]);
487 return;
488 }
489 }
490
491 pContext = GetContextRef();
492 if(!pContext) return;
493
494 if(pflValues)
495 {
496 if(LookupSource(pContext, source) != NULL)
497 {
498 switch(eParam)
499 {
500 default:
501 alSetError(pContext, AL_INVALID_ENUM);
502 break;
503 }
504 }
505 else
506 alSetError(pContext, AL_INVALID_NAME);
507 }
508 else
509 alSetError(pContext, AL_INVALID_VALUE);
510
511 ALCcontext_DecRef(pContext);
512 }
513
514
515 AL_API ALvoid AL_APIENTRY alSourcei(ALuint source,ALenum eParam,ALint lValue)
516 {
517 ALCcontext *pContext;
518 ALsource *Source;
519 ALbufferlistitem *BufferListItem;
520
521 switch(eParam)
522 {
523 case AL_MAX_DISTANCE:
524 case AL_ROLLOFF_FACTOR:
525 case AL_CONE_INNER_ANGLE:
526 case AL_CONE_OUTER_ANGLE:
527 case AL_REFERENCE_DISTANCE:
528 alSourcef(source, eParam, (ALfloat)lValue);
529 return;
530 }
531
532 pContext = GetContextRef();
533 if(!pContext) return;
534
535 if((Source=LookupSource(pContext, source)) != NULL)
536 {
537 ALCdevice *device = pContext->Device;
538
539 switch(eParam)
540 {
541 case AL_SOURCE_RELATIVE:
542 if(lValue == AL_FALSE || lValue == AL_TRUE)
543 {
544 Source->bHeadRelative = (ALboolean)lValue;
545 Source->NeedsUpdate = AL_TRUE;
546 }
547 else
548 alSetError(pContext, AL_INVALID_VALUE);
549 break;
550
551 case AL_LOOPING:
552 if(lValue == AL_FALSE || lValue == AL_TRUE)
553 Source->bLooping = (ALboolean)lValue;
554 else
555 alSetError(pContext, AL_INVALID_VALUE);
556 break;
557
558 case AL_BUFFER:
559 LockContext(pContext);
560 if(Source->state == AL_STOPPED || Source->state == AL_INITIAL)
561 {
562 ALbufferlistitem *oldlist;
563 ALbuffer *buffer = NULL;
564
565 if(lValue == 0 || (buffer=LookupBuffer(device, lValue)) != NULL)
566 {
567 Source->BuffersInQueue = 0;
568 Source->BuffersPlayed = 0;
569
570 // Add the buffer to the queue (as long as it is NOT the NULL buffer)
571 if(buffer != NULL)
572 {
573 // Source is now in STATIC mode
574 Source->lSourceType = AL_STATIC;
575
576 // Add the selected buffer to the queue
577 BufferListItem = malloc(sizeof(ALbufferlistitem));
578 BufferListItem->buffer = buffer;
579 BufferListItem->next = NULL;
580 BufferListItem->prev = NULL;
581 // Increment reference counter for buffer
582 IncrementRef(&buffer->ref);
583
584 oldlist = ExchangePtr((XchgPtr*)&Source->queue, BufferListItem);
585 Source->BuffersInQueue = 1;
586
587 ReadLock(&buffer->lock);
588 Source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);
589 Source->SampleSize = BytesFromFmt(buffer->FmtType);
590 ReadUnlock(&buffer->lock);
591 if(buffer->FmtChannels == FmtMono)
592 Source->Update = CalcSourceParams;
593 else
594 Source->Update = CalcNonAttnSourceParams;
595 Source->NeedsUpdate = AL_TRUE;
596 }
597 else
598 {
599 // Source is now in UNDETERMINED mode
600 Source->lSourceType = AL_UNDETERMINED;
601 oldlist = ExchangePtr((XchgPtr*)&Source->queue, NULL);
602 }
603
604 // Delete all previous elements in the queue
605 while(oldlist != NULL)
606 {
607 BufferListItem = oldlist;
608 oldlist = BufferListItem->next;
609
610 if(BufferListItem->buffer)
611 DecrementRef(&BufferListItem->buffer->ref);
612 free(BufferListItem);
613 }
614 }
615 else
616 alSetError(pContext, AL_INVALID_VALUE);
617 }
618 else
619 alSetError(pContext, AL_INVALID_OPERATION);
620 UnlockContext(pContext);
621 break;
622
623 case AL_SOURCE_STATE:
624 // Query only
625 alSetError(pContext, AL_INVALID_OPERATION);
626 break;
627
628 case AL_SEC_OFFSET:
629 case AL_SAMPLE_OFFSET:
630 case AL_BYTE_OFFSET:
631 if(lValue >= 0)
632 {
633 LockContext(pContext);
634 Source->lOffsetType = eParam;
635
636 // Store Offset (convert Seconds into Milliseconds)
637 if(eParam == AL_SEC_OFFSET)
638 Source->lOffset = lValue * 1000;
639 else
640 Source->lOffset = lValue;
641
642 if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
643 !pContext->DeferUpdates)
644 {
645 if(ApplyOffset(Source) == AL_FALSE)
646 alSetError(pContext, AL_INVALID_VALUE);
647 }
648 UnlockContext(pContext);
649 }
650 else
651 alSetError(pContext, AL_INVALID_VALUE);
652 break;
653
654 case AL_DIRECT_FILTER: {
655 ALfilter *filter = NULL;
656
657 if(lValue == 0 || (filter=LookupFilter(pContext->Device, lValue)) != NULL)
658 {
659 LockContext(pContext);
660 if(!filter)
661 {
662 Source->DirectGain = 1.0f;
663 Source->DirectGainHF = 1.0f;
664 }
665 else
666 {
667 Source->DirectGain = filter->Gain;
668 Source->DirectGainHF = filter->GainHF;
669 }
670 UnlockContext(pContext);
671 Source->NeedsUpdate = AL_TRUE;
672 }
673 else
674 alSetError(pContext, AL_INVALID_VALUE);
675 } break;
676
677 case AL_DIRECT_FILTER_GAINHF_AUTO:
678 if(lValue == AL_TRUE || lValue == AL_FALSE)
679 {
680 Source->DryGainHFAuto = lValue;
681 Source->NeedsUpdate = AL_TRUE;
682 }
683 else
684 alSetError(pContext, AL_INVALID_VALUE);
685 break;
686
687 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
688 if(lValue == AL_TRUE || lValue == AL_FALSE)
689 {
690 Source->WetGainAuto = lValue;
691 Source->NeedsUpdate = AL_TRUE;
692 }
693 else
694 alSetError(pContext, AL_INVALID_VALUE);
695 break;
696
697 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
698 if(lValue == AL_TRUE || lValue == AL_FALSE)
699 {
700 Source->WetGainHFAuto = lValue;
701 Source->NeedsUpdate = AL_TRUE;
702 }
703 else
704 alSetError(pContext, AL_INVALID_VALUE);
705 break;
706
707 case AL_DIRECT_CHANNELS_SOFT:
708 if(lValue == AL_TRUE || lValue == AL_FALSE)
709 {
710 Source->DirectChannels = lValue;
711 Source->NeedsUpdate = AL_TRUE;
712 }
713 else
714 alSetError(pContext, AL_INVALID_VALUE);
715 break;
716
717 case AL_DISTANCE_MODEL:
718 if(lValue == AL_NONE ||
719 lValue == AL_INVERSE_DISTANCE ||
720 lValue == AL_INVERSE_DISTANCE_CLAMPED ||
721 lValue == AL_LINEAR_DISTANCE ||
722 lValue == AL_LINEAR_DISTANCE_CLAMPED ||
723 lValue == AL_EXPONENT_DISTANCE ||
724 lValue == AL_EXPONENT_DISTANCE_CLAMPED)
725 {
726 Source->DistanceModel = lValue;
727 if(pContext->SourceDistanceModel)
728 Source->NeedsUpdate = AL_TRUE;
729 }
730 else
731 alSetError(pContext, AL_INVALID_VALUE);
732 break;
733
734 default:
735 alSetError(pContext, AL_INVALID_ENUM);
736 break;
737 }
738 }
739 else
740 alSetError(pContext, AL_INVALID_NAME);
741
742 ALCcontext_DecRef(pContext);
743 }
744
745
746 AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
747 {
748 ALCcontext *pContext;
749 ALsource *Source;
750
751 switch(eParam)
752 {
753 case AL_POSITION:
754 case AL_VELOCITY:
755 case AL_DIRECTION:
756 alSource3f(source, eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
757 return;
758 }
759
760 pContext = GetContextRef();
761 if(!pContext) return;
762
763 if((Source=LookupSource(pContext, source)) != NULL)
764 {
765 ALCdevice *device = pContext->Device;
766
767 switch(eParam)
768 {
769 case AL_AUXILIARY_SEND_FILTER: {
770 ALeffectslot *ALEffectSlot = NULL;
771 ALfilter *ALFilter = NULL;
772
773 LockContext(pContext);
774 if((ALuint)lValue2 < device->NumAuxSends &&
775 (lValue1 == 0 || (ALEffectSlot=LookupEffectSlot(pContext, lValue1)) != NULL) &&
776 (lValue3 == 0 || (ALFilter=LookupFilter(device, lValue3)) != NULL))
777 {
778 /* Release refcount on the previous slot, and add one for
779 * the new slot */
780 if(ALEffectSlot) IncrementRef(&ALEffectSlot->ref);
781 ALEffectSlot = ExchangePtr((XchgPtr*)&Source->Send[lValue2].Slot, ALEffectSlot);
782 if(ALEffectSlot) DecrementRef(&ALEffectSlot->ref);
783
784 if(!ALFilter)
785 {
786 /* Disable filter */
787 Source->Send[lValue2].WetGain = 1.0f;
788 Source->Send[lValue2].WetGainHF = 1.0f;
789 }
790 else
791 {
792 Source->Send[lValue2].WetGain = ALFilter->Gain;
793 Source->Send[lValue2].WetGainHF = ALFilter->GainHF;
794 }
795 Source->NeedsUpdate = AL_TRUE;
796 }
797 else
798 alSetError(pContext, AL_INVALID_VALUE);
799 UnlockContext(pContext);
800 } break;
801
802 default:
803 alSetError(pContext, AL_INVALID_ENUM);
804 break;
805 }
806 }
807 else
808 alSetError(pContext, AL_INVALID_NAME);
809
810 ALCcontext_DecRef(pContext);
811 }
812
813
814 AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum eParam, const ALint* plValues)
815 {
816 ALCcontext *pContext;
817
818 if(plValues)
819 {
820 switch(eParam)
821 {
822 case AL_SOURCE_RELATIVE:
823 case AL_CONE_INNER_ANGLE:
824 case AL_CONE_OUTER_ANGLE:
825 case AL_LOOPING:
826 case AL_BUFFER:
827 case AL_SOURCE_STATE:
828 case AL_SEC_OFFSET:
829 case AL_SAMPLE_OFFSET:
830 case AL_BYTE_OFFSET:
831 case AL_MAX_DISTANCE:
832 case AL_ROLLOFF_FACTOR:
833 case AL_REFERENCE_DISTANCE:
834 case AL_DIRECT_FILTER:
835 case AL_DIRECT_FILTER_GAINHF_AUTO:
836 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
837 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
838 case AL_DISTANCE_MODEL:
839 case AL_DIRECT_CHANNELS_SOFT:
840 alSourcei(source, eParam, plValues[0]);
841 return;
842
843 case AL_POSITION:
844 case AL_VELOCITY:
845 case AL_DIRECTION:
846 case AL_AUXILIARY_SEND_FILTER:
847 alSource3i(source, eParam, plValues[0], plValues[1], plValues[2]);
848 return;
849 }
850 }
851
852 pContext = GetContextRef();
853 if(!pContext) return;
854
855 if(plValues)
856 {
857 if(LookupSource(pContext, source) != NULL)
858 {
859 switch(eParam)
860 {
861 default:
862 alSetError(pContext, AL_INVALID_ENUM);
863 break;
864 }
865 }
866 else
867 alSetError(pContext, AL_INVALID_NAME);
868 }
869 else
870 alSetError(pContext, AL_INVALID_VALUE);
871
872 ALCcontext_DecRef(pContext);
873 }
874
875
876 AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflValue)
877 {
878 ALCcontext *pContext;
879 ALsource *Source;
880 ALdouble Offsets[2];
881 ALdouble updateLen;
882
883 pContext = GetContextRef();
884 if(!pContext) return;
885
886 if(pflValue)
887 {
888 if((Source=LookupSource(pContext, source)) != NULL)
889 {
890 switch(eParam)
891 {
892 case AL_PITCH:
893 *pflValue = Source->flPitch;
894 break;
895
896 case AL_GAIN:
897 *pflValue = Source->flGain;
898 break;
899
900 case AL_MIN_GAIN:
901 *pflValue = Source->flMinGain;
902 break;
903
904 case AL_MAX_GAIN:
905 *pflValue = Source->flMaxGain;
906 break;
907
908 case AL_MAX_DISTANCE:
909 *pflValue = Source->flMaxDistance;
910 break;
911
912 case AL_ROLLOFF_FACTOR:
913 *pflValue = Source->flRollOffFactor;
914 break;
915
916 case AL_CONE_OUTER_GAIN:
917 *pflValue = Source->flOuterGain;
918 break;
919
920 case AL_CONE_OUTER_GAINHF:
921 *pflValue = Source->OuterGainHF;
922 break;
923
924 case AL_SEC_OFFSET:
925 case AL_SAMPLE_OFFSET:
926 case AL_BYTE_OFFSET:
927 LockContext(pContext);
928 updateLen = (ALdouble)pContext->Device->UpdateSize /
929 pContext->Device->Frequency;
930 GetSourceOffset(Source, eParam, Offsets, updateLen);
931 UnlockContext(pContext);
932 *pflValue = (ALfloat)Offsets[0];
933 break;
934
935 case AL_CONE_INNER_ANGLE:
936 *pflValue = Source->flInnerAngle;
937 break;
938
939 case AL_CONE_OUTER_ANGLE:
940 *pflValue = Source->flOuterAngle;
941 break;
942
943 case AL_REFERENCE_DISTANCE:
944 *pflValue = Source->flRefDistance;
945 break;
946
947 case AL_AIR_ABSORPTION_FACTOR:
948 *pflValue = Source->AirAbsorptionFactor;
949 break;
950
951 case AL_ROOM_ROLLOFF_FACTOR:
952 *pflValue = Source->RoomRolloffFactor;
953 break;
954
955 case AL_DOPPLER_FACTOR:
956 *pflValue = Source->DopplerFactor;
957 break;
958
959 default:
960 alSetError(pContext, AL_INVALID_ENUM);
961 break;
962 }
963 }
964 else
965 alSetError(pContext, AL_INVALID_NAME);
966 }
967 else
968 alSetError(pContext, AL_INVALID_VALUE);
969
970 ALCcontext_DecRef(pContext);
971 }
972
973
974 AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
975 {
976 ALCcontext *pContext;
977 ALsource *Source;
978
979 pContext = GetContextRef();
980 if(!pContext) return;
981
982 if(pflValue1 && pflValue2 && pflValue3)
983 {
984 if((Source=LookupSource(pContext, source)) != NULL)
985 {
986 switch(eParam)
987 {
988 case AL_POSITION:
989 LockContext(pContext);
990 *pflValue1 = Source->vPosition[0];
991 *pflValue2 = Source->vPosition[1];
992 *pflValue3 = Source->vPosition[2];
993 UnlockContext(pContext);
994 break;
995
996 case AL_VELOCITY:
997 LockContext(pContext);
998 *pflValue1 = Source->vVelocity[0];
999 *pflValue2 = Source->vVelocity[1];
1000 *pflValue3 = Source->vVelocity[2];
1001 UnlockContext(pContext);
1002 break;
1003
1004 case AL_DIRECTION:
1005 LockContext(pContext);
1006 *pflValue1 = Source->vOrientation[0];
1007 *pflValue2 = Source->vOrientation[1];
1008 *pflValue3 = Source->vOrientation[2];
1009 UnlockContext(pContext);
1010 break;
1011
1012 default:
1013 alSetError(pContext, AL_INVALID_ENUM);
1014 break;
1015 }
1016 }
1017 else
1018 alSetError(pContext, AL_INVALID_NAME);
1019 }
1020 else
1021 alSetError(pContext, AL_INVALID_VALUE);
1022
1023 ALCcontext_DecRef(pContext);
1024 }
1025
1026
1027 AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum eParam, ALfloat *pflValues)
1028 {
1029 ALCcontext *pContext;
1030 ALsource *Source;
1031 ALdouble Offsets[2];
1032 ALdouble updateLen;
1033
1034 switch(eParam)
1035 {
1036 case AL_PITCH:
1037 case AL_GAIN:
1038 case AL_MIN_GAIN:
1039 case AL_MAX_GAIN:
1040 case AL_MAX_DISTANCE:
1041 case AL_ROLLOFF_FACTOR:
1042 case AL_DOPPLER_FACTOR:
1043 case AL_CONE_OUTER_GAIN:
1044 case AL_SEC_OFFSET:
1045 case AL_SAMPLE_OFFSET:
1046 case AL_BYTE_OFFSET:
1047 case AL_CONE_INNER_ANGLE:
1048 case AL_CONE_OUTER_ANGLE:
1049 case AL_REFERENCE_DISTANCE:
1050 case AL_CONE_OUTER_GAINHF:
1051 case AL_AIR_ABSORPTION_FACTOR:
1052 case AL_ROOM_ROLLOFF_FACTOR:
1053 alGetSourcef(source, eParam, pflValues);
1054 return;
1055
1056 case AL_POSITION:
1057 case AL_VELOCITY:
1058 case AL_DIRECTION:
1059 alGetSource3f(source, eParam, pflValues+0, pflValues+1, pflValues+2);
1060 return;
1061 }
1062
1063 pContext = GetContextRef();
1064 if(!pContext) return;
1065
1066 if(pflValues)
1067 {
1068 if((Source=LookupSource(pContext, source)) != NULL)
1069 {
1070 switch(eParam)
1071 {
1072 case AL_SAMPLE_RW_OFFSETS_SOFT:
1073 case AL_BYTE_RW_OFFSETS_SOFT:
1074 LockContext(pContext);
1075 updateLen = (ALdouble)pContext->Device->UpdateSize /
1076 pContext->Device->Frequency;
1077 GetSourceOffset(Source, eParam, Offsets, updateLen);
1078 UnlockContext(pContext);
1079 pflValues[0] = (ALfloat)Offsets[0];
1080 pflValues[1] = (ALfloat)Offsets[1];
1081 break;
1082
1083 default:
1084 alSetError(pContext, AL_INVALID_ENUM);
1085 break;
1086 }
1087 }
1088 else
1089 alSetError(pContext, AL_INVALID_NAME);
1090 }
1091 else
1092 alSetError(pContext, AL_INVALID_VALUE);
1093
1094 ALCcontext_DecRef(pContext);
1095 }
1096
1097
1098 AL_API ALvoid AL_APIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValue)
1099 {
1100 ALbufferlistitem *BufferList;
1101 ALCcontext *pContext;
1102 ALsource *Source;
1103 ALdouble Offsets[2];
1104 ALdouble updateLen;
1105
1106 pContext = GetContextRef();
1107 if(!pContext) return;
1108
1109 if(plValue)
1110 {
1111 if((Source=LookupSource(pContext, source)) != NULL)
1112 {
1113 switch(eParam)
1114 {
1115 case AL_MAX_DISTANCE:
1116 *plValue = (ALint)Source->flMaxDistance;
1117 break;
1118
1119 case AL_ROLLOFF_FACTOR:
1120 *plValue = (ALint)Source->flRollOffFactor;
1121 break;
1122
1123 case AL_REFERENCE_DISTANCE:
1124 *plValue = (ALint)Source->flRefDistance;
1125 break;
1126
1127 case AL_SOURCE_RELATIVE:
1128 *plValue = Source->bHeadRelative;
1129 break;
1130
1131 case AL_CONE_INNER_ANGLE:
1132 *plValue = (ALint)Source->flInnerAngle;
1133 break;
1134
1135 case AL_CONE_OUTER_ANGLE:
1136 *plValue = (ALint)Source->flOuterAngle;
1137 break;
1138
1139 case AL_LOOPING:
1140 *plValue = Source->bLooping;
1141 break;
1142
1143 case AL_BUFFER:
1144 LockContext(pContext);
1145 BufferList = Source->queue;
1146 if(Source->lSourceType != AL_STATIC)
1147 {
1148 ALuint i = Source->BuffersPlayed;
1149 while(i > 0)
1150 {
1151 BufferList = BufferList->next;
1152 i--;
1153 }
1154 }
1155 *plValue = ((BufferList && BufferList->buffer) ?
1156 BufferList->buffer->buffer : 0);
1157 UnlockContext(pContext);
1158 break;
1159
1160 case AL_SOURCE_STATE:
1161 *plValue = Source->state;
1162 break;
1163
1164 case AL_BUFFERS_QUEUED:
1165 *plValue = Source->BuffersInQueue;
1166 break;
1167
1168 case AL_BUFFERS_PROCESSED:
1169 LockContext(pContext);
1170 if(Source->bLooping || Source->lSourceType != AL_STREAMING)
1171 {
1172 /* Buffers on a looping source are in a perpetual state
1173 * of PENDING, so don't report any as PROCESSED */
1174 *plValue = 0;
1175 }
1176 else
1177 *plValue = Source->BuffersPlayed;
1178 UnlockContext(pContext);
1179 break;
1180
1181 case AL_SOURCE_TYPE:
1182 *plValue = Source->lSourceType;
1183 break;
1184
1185 case AL_SEC_OFFSET:
1186 case AL_SAMPLE_OFFSET:
1187 case AL_BYTE_OFFSET:
1188 LockContext(pContext);
1189 updateLen = (ALdouble)pContext->Device->UpdateSize /
1190 pContext->Device->Frequency;
1191 GetSourceOffset(Source, eParam, Offsets, updateLen);
1192 UnlockContext(pContext);
1193 *plValue = (ALint)Offsets[0];
1194 break;
1195
1196 case AL_DIRECT_FILTER_GAINHF_AUTO:
1197 *plValue = Source->DryGainHFAuto;
1198 break;
1199
1200 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1201 *plValue = Source->WetGainAuto;
1202 break;
1203
1204 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1205 *plValue = Source->WetGainHFAuto;
1206 break;
1207
1208 case AL_DOPPLER_FACTOR:
1209 *plValue = (ALint)Source->DopplerFactor;
1210 break;
1211
1212 case AL_DIRECT_CHANNELS_SOFT:
1213 *plValue = Source->DirectChannels;
1214 break;
1215
1216 case AL_DISTANCE_MODEL:
1217 *plValue = Source->DistanceModel;
1218 break;
1219
1220 default:
1221 alSetError(pContext, AL_INVALID_ENUM);
1222 break;
1223 }
1224 }
1225 else
1226 alSetError(pContext, AL_INVALID_NAME);
1227 }
1228 else
1229 alSetError(pContext, AL_INVALID_VALUE);
1230
1231 ALCcontext_DecRef(pContext);
1232 }
1233
1234
1235 AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
1236 {
1237 ALCcontext *pContext;
1238 ALsource *Source;
1239
1240 pContext = GetContextRef();
1241 if(!pContext) return;
1242
1243 if(plValue1 && plValue2 && plValue3)
1244 {
1245 if((Source=LookupSource(pContext, source)) != NULL)
1246 {
1247 switch(eParam)
1248 {
1249 case AL_POSITION:
1250 LockContext(pContext);
1251 *plValue1 = (ALint)Source->vPosition[0];
1252 *plValue2 = (ALint)Source->vPosition[1];
1253 *plValue3 = (ALint)Source->vPosition[2];
1254 UnlockContext(pContext);
1255 break;
1256
1257 case AL_VELOCITY:
1258 LockContext(pContext);
1259 *plValue1 = (ALint)Source->vVelocity[0];
1260 *plValue2 = (ALint)Source->vVelocity[1];
1261 *plValue3 = (ALint)Source->vVelocity[2];
1262 UnlockContext(pContext);
1263 break;
1264
1265 case AL_DIRECTION:
1266 LockContext(pContext);
1267 *plValue1 = (ALint)Source->vOrientation[0];
1268 *plValue2 = (ALint)Source->vOrientation[1];
1269 *plValue3 = (ALint)Source->vOrientation[2];
1270 UnlockContext(pContext);
1271 break;
1272
1273 default:
1274 alSetError(pContext, AL_INVALID_ENUM);
1275 break;
1276 }
1277 }
1278 else
1279 alSetError(pContext, AL_INVALID_NAME);
1280 }
1281 else
1282 alSetError(pContext, AL_INVALID_VALUE);
1283
1284 ALCcontext_DecRef(pContext);
1285 }
1286
1287
1288 AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum eParam, ALint* plValues)
1289 {
1290 ALCcontext *pContext;
1291 ALsource *Source;
1292 ALdouble Offsets[2];
1293 ALdouble updateLen;
1294
1295 switch(eParam)
1296 {
1297 case AL_SOURCE_RELATIVE:
1298 case AL_CONE_INNER_ANGLE:
1299 case AL_CONE_OUTER_ANGLE:
1300 case AL_LOOPING:
1301 case AL_BUFFER:
1302 case AL_SOURCE_STATE:
1303 case AL_BUFFERS_QUEUED:
1304 case AL_BUFFERS_PROCESSED:
1305 case AL_SEC_OFFSET:
1306 case AL_SAMPLE_OFFSET:
1307 case AL_BYTE_OFFSET:
1308 case AL_MAX_DISTANCE:
1309 case AL_ROLLOFF_FACTOR:
1310 case AL_DOPPLER_FACTOR:
1311 case AL_REFERENCE_DISTANCE:
1312 case AL_SOURCE_TYPE:
1313 case AL_DIRECT_FILTER:
1314 case AL_DIRECT_FILTER_GAINHF_AUTO:
1315 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1316 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1317 case AL_DISTANCE_MODEL:
1318 case AL_DIRECT_CHANNELS_SOFT:
1319 alGetSourcei(source, eParam, plValues);
1320 return;
1321
1322 case AL_POSITION:
1323 case AL_VELOCITY:
1324 case AL_DIRECTION:
1325 alGetSource3i(source, eParam, plValues+0, plValues+1, plValues+2);
1326 return;
1327 }
1328
1329 pContext = GetContextRef();
1330 if(!pContext) return;
1331
1332 if(plValues)
1333 {
1334 if((Source=LookupSource(pContext, source)) != NULL)
1335 {
1336 switch(eParam)
1337 {
1338 case AL_SAMPLE_RW_OFFSETS_SOFT:
1339 case AL_BYTE_RW_OFFSETS_SOFT:
1340 LockContext(pContext);
1341 updateLen = (ALdouble)pContext->Device->UpdateSize /
1342 pContext->Device->Frequency;
1343 GetSourceOffset(Source, eParam, Offsets, updateLen);
1344 UnlockContext(pContext);
1345 plValues[0] = (ALint)Offsets[0];
1346 plValues[1] = (ALint)Offsets[1];
1347 break;
1348
1349 default:
1350 alSetError(pContext, AL_INVALID_ENUM);
1351 break;
1352 }
1353 }
1354 else
1355 alSetError(pContext, AL_INVALID_NAME);
1356 }
1357 else
1358 alSetError(pContext, AL_INVALID_VALUE);
1359
1360 ALCcontext_DecRef(pContext);
1361 }
1362
1363
1364 AL_API ALvoid AL_APIENTRY alSourcePlay(ALuint source)
1365 {
1366 alSourcePlayv(1, &source);
1367 }
1368
1369 AL_API ALvoid AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)
1370 {
1371 ALCcontext *Context;
1372 ALsource *Source;
1373 ALsizei i;
1374
1375 Context = GetContextRef();
1376 if(!Context) return;
1377
1378 if(n < 0)
1379 {
1380 alSetError(Context, AL_INVALID_VALUE);
1381 goto done;
1382 }
1383 if(n > 0 && !sources)
1384 {
1385 alSetError(Context, AL_INVALID_VALUE);
1386 goto done;
1387 }
1388
1389 // Check that all the Sources are valid
1390 for(i = 0;i < n;i++)
1391 {
1392 if(!LookupSource(Context, sources[i]))
1393 {
1394 alSetError(Context, AL_INVALID_NAME);
1395 goto done;
1396 }
1397 }
1398
1399 LockContext(Context);
1400 while(Context->MaxActiveSources-Context->ActiveSourceCount < n)
1401 {
1402 void *temp = NULL;
1403 ALsizei newcount;
1404
1405 newcount = Context->MaxActiveSources << 1;
1406 if(newcount > 0)
1407 temp = realloc(Context->ActiveSources,
1408 sizeof(*Context->ActiveSources) * newcount);
1409 if(!temp)
1410 {
1411 UnlockContext(Context);
1412 alSetError(Context, AL_OUT_OF_MEMORY);
1413 goto done;
1414 }
1415
1416 Context->ActiveSources = temp;
1417 Context->MaxActiveSources = newcount;
1418 }
1419
1420 for(i = 0;i < n;i++)
1421 {
1422 Source = LookupSource(Context, sources[i]);
1423 if(Context->DeferUpdates) Source->new_state = AL_PLAYING;
1424 else SetSourceState(Source, Context, AL_PLAYING);
1425 }
1426 UnlockContext(Context);
1427
1428 done:
1429 ALCcontext_DecRef(Context);
1430 }
1431
1432 AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)
1433 {
1434 alSourcePausev(1, &source);
1435 }
1436
1437 AL_API ALvoid AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
1438 {
1439 ALCcontext *Context;
1440 ALsource *Source;
1441 ALsizei i;
1442
1443 Context = GetContextRef();
1444 if(!Context) return;
1445
1446 if(n < 0)
1447 {
1448 alSetError(Context, AL_INVALID_VALUE);
1449 goto done;
1450 }
1451 if(n > 0 && !sources)
1452 {
1453 alSetError(Context, AL_INVALID_VALUE);
1454 goto done;
1455 }
1456
1457 // Check all the Sources are valid
1458 for(i = 0;i < n;i++)
1459 {
1460 if(!LookupSource(Context, sources[i]))
1461 {
1462 alSetError(Context, AL_INVALID_NAME);
1463 goto done;
1464 }
1465 }
1466
1467 LockContext(Context);
1468 for(i = 0;i < n;i++)
1469 {
1470 Source = LookupSource(Context, sources[i]);
1471 if(Context->DeferUpdates) Source->new_state = AL_PAUSED;
1472 else SetSourceState(Source, Context, AL_PAUSED);
1473 }
1474 UnlockContext(Context);
1475
1476 done:
1477 ALCcontext_DecRef(Context);
1478 }
1479
1480 AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)
1481 {
1482 alSourceStopv(1, &source);
1483 }
1484
1485 AL_API ALvoid AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
1486 {
1487 ALCcontext *Context;
1488 ALsource *Source;
1489 ALsizei i;
1490
1491 Context = GetContextRef();
1492 if(!Context) return;
1493
1494 if(n < 0)
1495 {
1496 alSetError(Context, AL_INVALID_VALUE);
1497 goto done;
1498 }
1499 if(n > 0 && !sources)
1500 {
1501 alSetError(Context, AL_INVALID_VALUE);
1502 goto done;
1503 }
1504
1505 // Check all the Sources are valid
1506 for(i = 0;i < n;i++)
1507 {
1508 if(!LookupSource(Context, sources[i]))
1509 {
1510 alSetError(Context, AL_INVALID_NAME);
1511 goto done;
1512 }
1513 }
1514
1515 LockContext(Context);
1516 for(i = 0;i < n;i++)
1517 {
1518 Source = LookupSource(Context, sources[i]);
1519 Source->new_state = AL_NONE;
1520 SetSourceState(Source, Context, AL_STOPPED);
1521 }
1522 UnlockContext(Context);
1523
1524 done:
1525 ALCcontext_DecRef(Context);
1526 }
1527
1528 AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)
1529 {
1530 alSourceRewindv(1, &source);
1531 }
1532
1533 AL_API ALvoid AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
1534 {
1535 ALCcontext *Context;
1536 ALsource *Source;
1537 ALsizei i;
1538
1539 Context = GetContextRef();
1540 if(!Context) return;
1541
1542 if(n < 0)
1543 {
1544 alSetError(Context, AL_INVALID_VALUE);
1545 goto done;
1546 }
1547 if(n > 0 && !sources)
1548 {
1549 alSetError(Context, AL_INVALID_VALUE);
1550 goto done;
1551 }
1552
1553 // Check all the Sources are valid
1554 for(i = 0;i < n;i++)
1555 {
1556 if(!LookupSource(Context, sources[i]))
1557 {
1558 alSetError(Context, AL_INVALID_NAME);
1559 goto done;
1560 }
1561 }
1562
1563 LockContext(Context);
1564 for(i = 0;i < n;i++)
1565 {
1566 Source = LookupSource(Context, sources[i]);
1567 Source->new_state = AL_NONE;
1568 SetSourceState(Source, Context, AL_INITIAL);
1569 }
1570 UnlockContext(Context);
1571
1572 done:
1573 ALCcontext_DecRef(Context);
1574 }
1575
1576
1577 AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei n, const ALuint *buffers)
1578 {
1579 ALCcontext *Context;
1580 ALCdevice *device;
1581 ALsource *Source;
1582 ALsizei i;
1583 ALbufferlistitem *BufferListStart = NULL;
1584 ALbufferlistitem *BufferList;
1585 ALbuffer *BufferFmt;
1586
1587 if(n == 0)
1588 return;
1589
1590 Context = GetContextRef();
1591 if(!Context) return;
1592
1593 if(n < 0)
1594 {
1595 alSetError(Context, AL_INVALID_VALUE);
1596 goto error;
1597 }
1598
1599 // Check that all buffers are valid or zero and that the source is valid
1600
1601 // Check that this is a valid source
1602 if((Source=LookupSource(Context, source)) == NULL)
1603 {
1604 alSetError(Context, AL_INVALID_NAME);
1605 goto error;
1606 }
1607
1608 LockContext(Context);
1609 // Check that this is not a STATIC Source
1610 if(Source->lSourceType == AL_STATIC)
1611 {
1612 UnlockContext(Context);
1613 // Invalid Source Type (can't queue on a Static Source)
1614 alSetError(Context, AL_INVALID_OPERATION);
1615 goto error;
1616 }
1617
1618 device = Context->Device;
1619
1620 BufferFmt = NULL;
1621
1622 // Check existing Queue (if any) for a valid Buffers and get its frequency and format
1623 BufferList = Source->queue;
1624 while(BufferList)
1625 {
1626 if(BufferList->buffer)
1627 {
1628 BufferFmt = BufferList->buffer;
1629 break;
1630 }
1631 BufferList = BufferList->next;
1632 }
1633
1634 for(i = 0;i < n;i++)
1635 {
1636 ALbuffer *buffer = NULL;
1637 if(buffers[i] && (buffer=LookupBuffer(device, buffers[i])) == NULL)
1638 {
1639 UnlockContext(Context);
1640 alSetError(Context, AL_INVALID_NAME);
1641 goto error;
1642 }
1643
1644 if(!BufferListStart)
1645 {
1646 BufferListStart = malloc(sizeof(ALbufferlistitem));
1647 BufferListStart->buffer = buffer;
1648 BufferListStart->next = NULL;
1649 BufferListStart->prev = NULL;
1650 BufferList = BufferListStart;
1651 }
1652 else
1653 {
1654 BufferList->next = malloc(sizeof(ALbufferlistitem));
1655 BufferList->next->buffer = buffer;
1656 BufferList->next->next = NULL;
1657 BufferList->next->prev = BufferList;
1658 BufferList = BufferList->next;
1659 }
1660 if(!buffer) continue;
1661
1662 // Increment reference counter for buffer
1663 IncrementRef(&buffer->ref);
1664 ReadLock(&buffer->lock);
1665 if(BufferFmt == NULL)
1666 {
1667 BufferFmt = buffer;
1668
1669 Source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);
1670 Source->SampleSize = BytesFromFmt(buffer->FmtType);
1671 if(buffer->FmtChannels == FmtMono)
1672 Source->Update = CalcSourceParams;
1673 else
1674 Source->Update = CalcNonAttnSourceParams;
1675
1676 Source->NeedsUpdate = AL_TRUE;
1677 }
1678 else if(BufferFmt->Frequency != buffer->Frequency ||
1679 BufferFmt->OriginalChannels != buffer->OriginalChannels ||
1680 BufferFmt->OriginalType != buffer->OriginalType)
1681 {
1682 ReadUnlock(&buffer->lock);
1683 UnlockContext(Context);
1684 alSetError(Context, AL_INVALID_OPERATION);
1685 goto error;
1686 }
1687 ReadUnlock(&buffer->lock);
1688 }
1689
1690 // Change Source Type
1691 Source->lSourceType = AL_STREAMING;
1692
1693 if(Source->queue == NULL)
1694 Source->queue = BufferListStart;
1695 else
1696 {
1697 // Find end of queue
1698 BufferList = Source->queue;
1699 while(BufferList->next != NULL)
1700 BufferList = BufferList->next;
1701
1702 BufferListStart->prev = BufferList;
1703 BufferList->next = BufferListStart;
1704 }
1705
1706 // Update number of buffers in queue
1707 Source->BuffersInQueue += n;
1708
1709 UnlockContext(Context);
1710 ALCcontext_DecRef(Context);
1711 return;
1712
1713 error:
1714 while(BufferListStart)
1715 {
1716 BufferList = BufferListStart;
1717 BufferListStart = BufferList->next;
1718
1719 if(BufferList->buffer)
1720 DecrementRef(&BufferList->buffer->ref);
1721 free(BufferList);
1722 }
1723 ALCcontext_DecRef(Context);
1724 }
1725
1726
1727 // Implementation assumes that n is the number of buffers to be removed from the queue and buffers is
1728 // an array of buffer IDs that are to be filled with the names of the buffers removed
1729 AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers )
1730 {
1731 ALCcontext *Context;
1732 ALsource *Source;
1733 ALsizei i;
1734 ALbufferlistitem *BufferList;
1735
1736 if(n == 0)
1737 return;
1738
1739 Context = GetContextRef();
1740 if(!Context) return;
1741
1742 if(n < 0)
1743 {
1744 alSetError(Context, AL_INVALID_VALUE);
1745 goto done;
1746 }
1747
1748 if((Source=LookupSource(Context, source)) == NULL)
1749 {
1750 alSetError(Context, AL_INVALID_NAME);
1751 goto done;
1752 }
1753
1754 LockContext(Context);
1755 if(Source->bLooping || Source->lSourceType != AL_STREAMING ||
1756 (ALuint)n > Source->BuffersPlayed)
1757 {
1758 UnlockContext(Context);
1759 // Some buffers can't be unqueue because they have not been processed
1760 alSetError(Context, AL_INVALID_VALUE);
1761 goto done;
1762 }
1763
1764 for(i = 0;i < n;i++)
1765 {
1766 BufferList = Source->queue;
1767 Source->queue = BufferList->next;
1768 Source->BuffersInQueue--;
1769 Source->BuffersPlayed--;
1770
1771 if(BufferList->buffer)
1772 {
1773 // Record name of buffer
1774 buffers[i] = BufferList->buffer->buffer;
1775 // Decrement buffer reference counter
1776 DecrementRef(&BufferList->buffer->ref);
1777 }
1778 else
1779 buffers[i] = 0;
1780
1781 // Release memory for buffer list item
1782 free(BufferList);
1783 }
1784 if(Source->queue)
1785 Source->queue->prev = NULL;
1786 UnlockContext(Context);
1787
1788 done:
1789 ALCcontext_DecRef(Context);
1790 }
1791
1792
1793 static ALvoid InitSourceParams(ALsource *Source)
1794 {
1795 ALuint i;
1796
1797 Source->flInnerAngle = 360.0f;
1798 Source->flOuterAngle = 360.0f;
1799 Source->flPitch = 1.0f;
1800 Source->vPosition[0] = 0.0f;
1801 Source->vPosition[1] = 0.0f;
1802 Source->vPosition[2] = 0.0f;
1803 Source->vOrientation[0] = 0.0f;
1804 Source->vOrientation[1] = 0.0f;
1805 Source->vOrientation[2] = 0.0f;
1806 Source->vVelocity[0] = 0.0f;
1807 Source->vVelocity[1] = 0.0f;
1808 Source->vVelocity[2] = 0.0f;
1809 Source->flRefDistance = 1.0f;
1810 Source->flMaxDistance = FLT_MAX;
1811 Source->flRollOffFactor = 1.0f;
1812 Source->bLooping = AL_FALSE;
1813 Source->flGain = 1.0f;
1814 Source->flMinGain = 0.0f;
1815 Source->flMaxGain = 1.0f;
1816 Source->flOuterGain = 0.0f;
1817 Source->OuterGainHF = 1.0f;
1818
1819 Source->DryGainHFAuto = AL_TRUE;
1820 Source->WetGainAuto = AL_TRUE;
1821 Source->WetGainHFAuto = AL_TRUE;
1822 Source->AirAbsorptionFactor = 0.0f;
1823 Source->RoomRolloffFactor = 0.0f;
1824 Source->DopplerFactor = 1.0f;
1825 Source->DirectChannels = AL_FALSE;
1826
1827 Source->DistanceModel = DefaultDistanceModel;
1828
1829 Source->Resampler = DefaultResampler;
1830
1831 Source->state = AL_INITIAL;
1832 Source->new_state = AL_NONE;
1833 Source->lSourceType = AL_UNDETERMINED;
1834 Source->lOffset = -1;
1835
1836 Source->DirectGain = 1.0f;
1837 Source->DirectGainHF = 1.0f;
1838 for(i = 0;i < MAX_SENDS;i++)
1839 {
1840 Source->Send[i].WetGain = 1.0f;
1841 Source->Send[i].WetGainHF = 1.0f;
1842 }
1843
1844 Source->NeedsUpdate = AL_TRUE;
1845
1846 Source->HrtfMoving = AL_FALSE;
1847 Source->HrtfCounter = 0;
1848 }
1849
1850
1851 /*
1852 * SetSourceState
1853 *
1854 * Sets the source's new play state given its current state
1855 */
1856 ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)
1857 {
1858 if(state == AL_PLAYING)
1859 {
1860 ALbufferlistitem *BufferList;
1861 ALsizei j, k;
1862
1863 /* Check that there is a queue containing at least one non-null, non zero length AL Buffer */
1864 BufferList = Source->queue;
1865 while(BufferList)
1866 {
1867 if(BufferList->buffer != NULL && BufferList->buffer->SampleLen)
1868 break;
1869 BufferList = BufferList->next;
1870 }
1871
1872 if(Source->state != AL_PLAYING)
1873 {
1874 for(j = 0;j < MAXCHANNELS;j++)
1875 {
1876 for(k = 0;k < SRC_HISTORY_LENGTH;k++)
1877 Source->HrtfHistory[j][k] = 0.0f;
1878 for(k = 0;k < HRIR_LENGTH;k++)
1879 {
1880 Source->HrtfValues[j][k][0] = 0.0f;
1881 Source->HrtfValues[j][k][1] = 0.0f;
1882 }
1883 }
1884 }
1885
1886 if(Source->state != AL_PAUSED)
1887 {
1888 Source->state = AL_PLAYING;
1889 Source->position = 0;
1890 Source->position_fraction = 0;
1891 Source->BuffersPlayed = 0;
1892 }
1893 else
1894 Source->state = AL_PLAYING;
1895
1896 // Check if an Offset has been set
1897 if(Source->lOffset != -1)
1898 ApplyOffset(Source);
1899
1900 /* If there's nothing to play, or device is disconnected, go right to
1901 * stopped */
1902 if(!BufferList || !Context->Device->Connected)
1903 {
1904 SetSourceState(Source, Context, AL_STOPPED);
1905 return;
1906 }
1907
1908 for(j = 0;j < Context->ActiveSourceCount;j++)
1909 {
1910 if(Context->ActiveSources[j] == Source)
1911 break;
1912 }
1913 if(j == Context->ActiveSourceCount)
1914 Context->ActiveSources[Context->ActiveSourceCount++] = Source;
1915 }
1916 else if(state == AL_PAUSED)
1917 {
1918 if(Source->state == AL_PLAYING)
1919 {
1920 Source->state = AL_PAUSED;
1921 Source->HrtfMoving = AL_FALSE;
1922 Source->HrtfCounter = 0;
1923 }
1924 }
1925 else if(state == AL_STOPPED)
1926 {
1927 if(Source->state != AL_INITIAL)
1928 {
1929 Source->state = AL_STOPPED;
1930 Source->BuffersPlayed = Source->BuffersInQueue;
1931 Source->HrtfMoving = AL_FALSE;
1932 Source->HrtfCounter = 0;
1933 }
1934 Source->lOffset = -1;
1935 }
1936 else if(state == AL_INITIAL)
1937 {
1938 if(Source->state != AL_INITIAL)
1939 {
1940 Source->state = AL_INITIAL;
1941 Source->position = 0;
1942 Source->position_fraction = 0;
1943 Source->BuffersPlayed = 0;
1944 Source->HrtfMoving = AL_FALSE;
1945 Source->HrtfCounter = 0;
1946 }
1947 Source->lOffset = -1;
1948 }
1949 }
1950
1951 /*
1952 GetSourceOffset
1953
1954 Gets the current playback position in the given Source, in the appropriate format (Bytes, Samples or MilliSeconds)
1955 The offset is relative to the start of the queue (not the start of the current buffer)
1956 */
1957 static ALvoid GetSourceOffset(ALsource *Source, ALenum name, ALdouble *offset, ALdouble updateLen)
1958 {
1959 const ALbufferlistitem *BufferList;
1960 const ALbuffer *Buffer = NULL;
1961 ALuint BufferFreq = 0;
1962 ALuint readPos, writePos;
1963 ALuint totalBufferLen;
1964 ALuint i;
1965
1966 // Find the first non-NULL Buffer in the Queue
1967 BufferList = Source->queue;
1968 while(BufferList)
1969 {
1970 if(BufferList->buffer)
1971 {
1972 Buffer = BufferList->buffer;
1973 BufferFreq = Buffer->Frequency;
1974 break;
1975 }
1976 BufferList = BufferList->next;
1977 }
1978
1979 if((Source->state != AL_PLAYING && Source->state != AL_PAUSED) || !Buffer)
1980 {
1981 offset[0] = 0.0;
1982 offset[1] = 0.0;
1983 return;
1984 }
1985
1986 if(updateLen > 0.0 && updateLen < 0.015)
1987 updateLen = 0.015;
1988
1989 // Get Current SamplesPlayed (NOTE : This is the offset into the *current* buffer)
1990 readPos = Source->position;
1991 // Add length of any processed buffers in the queue
1992 totalBufferLen = 0;
1993 BufferList = Source->queue;
1994 for(i = 0;BufferList;i++)
1995 {
1996 if(BufferList->buffer)
1997 {
1998 if(i < Source->BuffersPlayed)
1999 readPos += BufferList->buffer->SampleLen;
2000 totalBufferLen += BufferList->buffer->SampleLen;
2001 }
2002 BufferList = BufferList->next;
2003 }
2004 if(Source->state == AL_PLAYING)
2005 writePos = readPos + (ALuint)(updateLen*BufferFreq);
2006 else
2007 writePos = readPos;
2008
2009 if(Source->bLooping)
2010 {
2011 readPos %= totalBufferLen;
2012 writePos %= totalBufferLen;
2013 }
2014 else
2015 {
2016 // Wrap positions back to 0
2017 if(readPos >= totalBufferLen)
2018 readPos = 0;
2019 if(writePos >= totalBufferLen)
2020 writePos = 0;
2021 }
2022
2023 switch(name)
2024 {
2025 case AL_SEC_OFFSET:
2026 offset[0] = (ALdouble)readPos / Buffer->Frequency;
2027 offset[1] = (ALdouble)writePos / Buffer->Frequency;
2028 break;
2029 case AL_SAMPLE_OFFSET:
2030 case AL_SAMPLE_RW_OFFSETS_SOFT:
2031 offset[0] = (ALdouble)readPos;
2032 offset[1] = (ALdouble)writePos;
2033 break;
2034 case AL_BYTE_OFFSET:
2035 case AL_BYTE_RW_OFFSETS_SOFT:
2036 // Take into account the original format of the Buffer
2037 if(Buffer->OriginalType == UserFmtIMA4)
2038 {
2039 ALuint BlockSize = 36 * ChannelsFromFmt(Buffer->FmtChannels);
2040 ALuint FrameBlockSize = 65;
2041
2042 // Round down to nearest ADPCM block
2043 offset[0] = (ALdouble)(readPos / FrameBlockSize * BlockSize);
2044 if(Source->state != AL_PLAYING)
2045 offset[1] = offset[0];
2046 else
2047 {
2048 // Round up to nearest ADPCM block
2049 offset[1] = (ALdouble)((writePos+FrameBlockSize-1) /
2050 FrameBlockSize * BlockSize);
2051 }
2052 }
2053 else
2054 {
2055 ALuint FrameSize = FrameSizeFromUserFmt(Buffer->OriginalChannels, Buffer->OriginalType);
2056 offset[0] = (ALdouble)(readPos * FrameSize);
2057 offset[1] = (ALdouble)(writePos * FrameSize);
2058 }
2059 break;
2060 }
2061 }
2062
2063
2064 /*
2065 ApplyOffset
2066
2067 Apply a playback offset to the Source. This function will update the queue (to correctly
2068 mark buffers as 'pending' or 'processed' depending upon the new offset.
2069 */
2070 ALboolean ApplyOffset(ALsource *Source)
2071 {
2072 const ALbufferlistitem *BufferList;
2073 const ALbuffer *Buffer;
2074 ALint bufferLen, totalBufferLen;
2075 ALint buffersPlayed;
2076 ALint offset;
2077
2078 // Get true byte offset
2079 offset = GetSampleOffset(Source);
2080
2081 // If the offset is invalid, don't apply it
2082 if(offset == -1)
2083 return AL_FALSE;
2084
2085 // Sort out the queue (pending and processed states)
2086 BufferList = Source->queue;
2087 totalBufferLen = 0;
2088 buffersPlayed = 0;
2089
2090 while(BufferList)
2091 {
2092 Buffer = BufferList->buffer;
2093 bufferLen = Buffer ? Buffer->SampleLen : 0;
2094
2095 if(bufferLen <= offset-totalBufferLen)
2096 {
2097 // Offset is past this buffer so increment BuffersPlayed
2098 buffersPlayed++;
2099 }
2100 else if(totalBufferLen <= offset)
2101 {
2102 // Offset is within this buffer
2103 Source->BuffersPlayed = buffersPlayed;
2104
2105 // SW Mixer Positions are in Samples
2106 Source->position = offset - totalBufferLen;
2107 return AL_TRUE;
2108 }
2109
2110 // Increment the TotalBufferSize
2111 totalBufferLen += bufferLen;
2112
2113 // Move on to next buffer in the Queue
2114 BufferList = BufferList->next;
2115 }
2116 // Offset is out of range of the buffer queue
2117 return AL_FALSE;
2118 }
2119
2120
2121 /*
2122 GetSampleOffset
2123
2124 Returns the sample offset into the Source's queue (from the Sample, Byte or Millisecond offset
2125 supplied by the application). This takes into account the fact that the buffer format may have
2126 been modifed by AL
2127 */
2128 static ALint GetSampleOffset(ALsource *Source)
2129 {
2130 const ALbuffer *Buffer = NULL;
2131 const ALbufferlistitem *BufferList;
2132 ALint Offset = -1;
2133
2134 // Find the first non-NULL Buffer in the Queue
2135 BufferList = Source->queue;
2136 while(BufferList)
2137 {
2138 if(BufferList->buffer)
2139 {
2140 Buffer = BufferList->buffer;
2141 break;
2142 }
2143 BufferList = BufferList->next;
2144 }
2145
2146 if(!Buffer)
2147 {
2148 Source->lOffset = -1;
2149 return -1;
2150 }
2151
2152 // Determine the ByteOffset (and ensure it is block aligned)
2153 switch(Source->lOffsetType)
2154 {
2155 case AL_BYTE_OFFSET:
2156 // Take into consideration the original format
2157 Offset = Source->lOffset;
2158 if(Buffer->OriginalType == UserFmtIMA4)
2159 {
2160 // Round down to nearest ADPCM block
2161 Offset /= 36 * ChannelsFromUserFmt(Buffer->OriginalChannels);
2162 // Multiply by compression rate (65 sample frames per block)
2163 Offset *= 65;
2164 }
2165 else
2166 Offset /= FrameSizeFromUserFmt(Buffer->OriginalChannels, Buffer->OriginalType);
2167 break;
2168
2169 case AL_SAMPLE_OFFSET:
2170 Offset = Source->lOffset;
2171 break;
2172
2173 case AL_SEC_OFFSET:
2174 // Note - lOffset is internally stored as Milliseconds
2175 Offset = (ALint)(Source->lOffset / 1000.0 * Buffer->Frequency);
2176 break;
2177 }
2178 // Clear Offset
2179 Source->lOffset = -1;
2180
2181 return Offset;
2182 }
2183
2184
2185 ALvoid ReleaseALSources(ALCcontext *Context)
2186 {
2187 ALsizei pos;
2188 ALuint j;
2189 for(pos = 0;pos < Context->SourceMap.size;pos++)
2190 {
2191 ALsource *temp = Context->SourceMap.array[pos].value;
2192 Context->SourceMap.array[pos].value = NULL;
2193
2194 // For each buffer in the source's queue, decrement its reference counter and remove it
2195 while(temp->queue != NULL)
2196 {
2197 ALbufferlistitem *BufferList = temp->queue;
2198 temp->queue = BufferList->next;
2199
2200 if(BufferList->buffer != NULL)
2201 DecrementRef(&BufferList->buffer->ref);
2202 free(BufferList);
2203 }
2204
2205 for(j = 0;j < MAX_SENDS;++j)
2206 {
2207 if(temp->Send[j].Slot)
2208 DecrementRef(&temp->Send[j].Slot->ref);
2209 temp->Send[j].Slot = NULL;
2210 }
2211
2212 // Release source structure
2213 FreeThunkEntry(temp->source);
2214 memset(temp, 0, sizeof(ALsource));
2215 free(temp);
2216 }
2217 }
Software OpenAL implementation