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