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