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