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