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