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