?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use a plain mutex for the property lock
[openal-soft.git] / OpenAL32 / alSource.c
blob025113821d7801611e3511d5a04694d61c97c802
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.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 <limits.h>
25 #include <math.h>
26 #include <float.h>
27
28 #include "AL/al.h"
29 #include "AL/alc.h"
30 #include "alMain.h"
31 #include "alError.h"
32 #include "alSource.h"
33 #include "alBuffer.h"
34 #include "alAuxEffectSlot.h"
35 #include "ringbuffer.h"
36
37 #include "backends/base.h"
38
39 #include "threads.h"
40 #include "almalloc.h"
41
42
43 static ALsource *AllocSource(ALCcontext *context);
44 static void FreeSource(ALCcontext *context, ALsource *source);
45 static void InitSourceParams(ALsource *Source, ALsizei num_sends);
46 static void DeinitSource(ALsource *source, ALsizei num_sends);
47 static void UpdateSourceProps(ALsource *source, ALvoice *voice, ALsizei num_sends, ALCcontext *context);
48 static ALint64 GetSourceSampleOffset(ALsource *Source, ALCcontext *context, ALuint64 *clocktime);
49 static ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, ALuint64 *clocktime);
50 static ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context);
51 static ALboolean GetSampleOffset(ALsource *Source, ALuint *offset, ALsizei *frac);
52 static ALboolean ApplyOffset(ALsource *Source, ALvoice *voice);
53
54 static inline void LockSourceList(ALCcontext *context)
55 { almtx_lock(&context->SourceLock); }
56 static inline void UnlockSourceList(ALCcontext *context)
57 { almtx_unlock(&context->SourceLock); }
58
59 static inline ALsource *LookupSource(ALCcontext *context, ALuint id)
60 {
61 SourceSubList *sublist;
62 ALuint lidx = (id-1) >> 6;
63 ALsizei slidx = (id-1) & 0x3f;
64
65 if(UNLIKELY(lidx >= VECTOR_SIZE(context->SourceList)))
66 return NULL;
67 sublist = &VECTOR_ELEM(context->SourceList, lidx);
68 if(UNLIKELY(sublist->FreeMask & (U64(1)<<slidx)))
69 return NULL;
70 return sublist->Sources + slidx;
71 }
72
73 static inline ALbuffer *LookupBuffer(ALCdevice *device, ALuint id)
74 {
75 BufferSubList *sublist;
76 ALuint lidx = (id-1) >> 6;
77 ALsizei slidx = (id-1) & 0x3f;
78
79 if(UNLIKELY(lidx >= VECTOR_SIZE(device->BufferList)))
80 return NULL;
81 sublist = &VECTOR_ELEM(device->BufferList, lidx);
82 if(UNLIKELY(sublist->FreeMask & (U64(1)<<slidx)))
83 return NULL;
84 return sublist->Buffers + slidx;
85 }
86
87 static inline ALfilter *LookupFilter(ALCdevice *device, ALuint id)
88 {
89 FilterSubList *sublist;
90 ALuint lidx = (id-1) >> 6;
91 ALsizei slidx = (id-1) & 0x3f;
92
93 if(UNLIKELY(lidx >= VECTOR_SIZE(device->FilterList)))
94 return NULL;
95 sublist = &VECTOR_ELEM(device->FilterList, lidx);
96 if(UNLIKELY(sublist->FreeMask & (U64(1)<<slidx)))
97 return NULL;
98 return sublist->Filters + slidx;
99 }
100
101 static inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id)
102 {
103 id--;
104 if(UNLIKELY(id >= VECTOR_SIZE(context->EffectSlotList)))
105 return NULL;
106 return VECTOR_ELEM(context->EffectSlotList, id);
107 }
108
109
110 typedef enum SourceProp {
111 srcPitch = AL_PITCH,
112 srcGain = AL_GAIN,
113 srcMinGain = AL_MIN_GAIN,
114 srcMaxGain = AL_MAX_GAIN,
115 srcMaxDistance = AL_MAX_DISTANCE,
116 srcRolloffFactor = AL_ROLLOFF_FACTOR,
117 srcDopplerFactor = AL_DOPPLER_FACTOR,
118 srcConeOuterGain = AL_CONE_OUTER_GAIN,
119 srcSecOffset = AL_SEC_OFFSET,
120 srcSampleOffset = AL_SAMPLE_OFFSET,
121 srcByteOffset = AL_BYTE_OFFSET,
122 srcConeInnerAngle = AL_CONE_INNER_ANGLE,
123 srcConeOuterAngle = AL_CONE_OUTER_ANGLE,
124 srcRefDistance = AL_REFERENCE_DISTANCE,
125
126 srcPosition = AL_POSITION,
127 srcVelocity = AL_VELOCITY,
128 srcDirection = AL_DIRECTION,
129
130 srcSourceRelative = AL_SOURCE_RELATIVE,
131 srcLooping = AL_LOOPING,
132 srcBuffer = AL_BUFFER,
133 srcSourceState = AL_SOURCE_STATE,
134 srcBuffersQueued = AL_BUFFERS_QUEUED,
135 srcBuffersProcessed = AL_BUFFERS_PROCESSED,
136 srcSourceType = AL_SOURCE_TYPE,
137
138 /* ALC_EXT_EFX */
139 srcConeOuterGainHF = AL_CONE_OUTER_GAINHF,
140 srcAirAbsorptionFactor = AL_AIR_ABSORPTION_FACTOR,
141 srcRoomRolloffFactor = AL_ROOM_ROLLOFF_FACTOR,
142 srcDirectFilterGainHFAuto = AL_DIRECT_FILTER_GAINHF_AUTO,
143 srcAuxSendFilterGainAuto = AL_AUXILIARY_SEND_FILTER_GAIN_AUTO,
144 srcAuxSendFilterGainHFAuto = AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO,
145 srcDirectFilter = AL_DIRECT_FILTER,
146 srcAuxSendFilter = AL_AUXILIARY_SEND_FILTER,
147
148 /* AL_SOFT_direct_channels */
149 srcDirectChannelsSOFT = AL_DIRECT_CHANNELS_SOFT,
150
151 /* AL_EXT_source_distance_model */
152 srcDistanceModel = AL_DISTANCE_MODEL,
153
154 /* AL_SOFT_source_latency */
155 srcSampleOffsetLatencySOFT = AL_SAMPLE_OFFSET_LATENCY_SOFT,
156 srcSecOffsetLatencySOFT = AL_SEC_OFFSET_LATENCY_SOFT,
157
158 /* AL_EXT_STEREO_ANGLES */
159 srcAngles = AL_STEREO_ANGLES,
160
161 /* AL_EXT_SOURCE_RADIUS */
162 srcRadius = AL_SOURCE_RADIUS,
163
164 /* AL_EXT_BFORMAT */
165 srcOrientation = AL_ORIENTATION,
166
167 /* AL_SOFT_source_resampler */
168 srcResampler = AL_SOURCE_RESAMPLER_SOFT,
169
170 /* AL_SOFT_source_spatialize */
171 srcSpatialize = AL_SOURCE_SPATIALIZE_SOFT,
172
173 /* ALC_SOFT_device_clock */
174 srcSampleOffsetClockSOFT = AL_SAMPLE_OFFSET_CLOCK_SOFT,
175 srcSecOffsetClockSOFT = AL_SEC_OFFSET_CLOCK_SOFT,
176 } SourceProp;
177
178 static ALboolean SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const ALfloat *values);
179 static ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const ALint *values);
180 static ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const ALint64SOFT *values);
181
182 static ALboolean GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, ALdouble *values);
183 static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, ALint *values);
184 static ALboolean GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, ALint64 *values);
185
186 static inline ALvoice *GetSourceVoice(ALsource *source, ALCcontext *context)
187 {
188 ALint idx = source->VoiceIdx;
189 if(idx >= 0 && idx < context->VoiceCount)
190 {
191 ALvoice *voice = context->Voices[idx];
192 if(ATOMIC_LOAD(&voice->Source, almemory_order_acquire) == source)
193 return voice;
194 }
195 source->VoiceIdx = -1;
196 return NULL;
197 }
198
199 /**
200 * Returns if the last known state for the source was playing or paused. Does
201 * not sync with the mixer voice.
202 */
203 static inline bool IsPlayingOrPaused(ALsource *source)
204 { return source->state == AL_PLAYING || source->state == AL_PAUSED; }
205
206 /**
207 * Returns an updated source state using the matching voice's status (or lack
208 * thereof).
209 */
210 static inline ALenum GetSourceState(ALsource *source, ALvoice *voice)
211 {
212 if(!voice && source->state == AL_PLAYING)
213 source->state = AL_STOPPED;
214 return source->state;
215 }
216
217 /**
218 * Returns if the source should specify an update, given the context's
219 * deferring state and the source's last known state.
220 */
221 static inline bool SourceShouldUpdate(ALsource *source, ALCcontext *context)
222 {
223 return !ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire) &&
224 IsPlayingOrPaused(source);
225 }
226
227
228 /** Can only be called while the mixer is locked! */
229 static void SendStateChangeEvent(ALCcontext *context, ALuint id, ALenum state)
230 {
231 ALbitfieldSOFT enabledevt;
232 AsyncEvent evt;
233
234 enabledevt = ATOMIC_LOAD(&context->EnabledEvts, almemory_order_acquire);
235 if(!(enabledevt&EventType_SourceStateChange)) return;
236
237 evt.EnumType = EventType_SourceStateChange;
238 evt.Type = AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT;
239 evt.ObjectId = id;
240 evt.Param = state;
241 snprintf(evt.Message, sizeof(evt.Message), "Source ID %u state changed to %s", id,
242 (state==AL_INITIAL) ? "AL_INITIAL" :
243 (state==AL_PLAYING) ? "AL_PLAYING" :
244 (state==AL_PAUSED) ? "AL_PAUSED" :
245 (state==AL_STOPPED) ? "AL_STOPPED" : "<unknown>"
246 );
247 /* The mixer may have queued a state change that's not yet been processed,
248 * and we don't want state change messages to occur out of order, so send
249 * it through the async queue to ensure proper ordering.
250 */
251 if(ll_ringbuffer_write_space(context->AsyncEvents) > 0)
252 ll_ringbuffer_write(context->AsyncEvents, (const char*)&evt, 1);
253 alsem_post(&context->EventSem);
254 }
255
256
257 static ALint FloatValsByProp(ALenum prop)
258 {
259 if(prop != (ALenum)((SourceProp)prop))
260 return 0;
261 switch((SourceProp)prop)
262 {
263 case AL_PITCH:
264 case AL_GAIN:
265 case AL_MIN_GAIN:
266 case AL_MAX_GAIN:
267 case AL_MAX_DISTANCE:
268 case AL_ROLLOFF_FACTOR:
269 case AL_DOPPLER_FACTOR:
270 case AL_CONE_OUTER_GAIN:
271 case AL_SEC_OFFSET:
272 case AL_SAMPLE_OFFSET:
273 case AL_BYTE_OFFSET:
274 case AL_CONE_INNER_ANGLE:
275 case AL_CONE_OUTER_ANGLE:
276 case AL_REFERENCE_DISTANCE:
277 case AL_CONE_OUTER_GAINHF:
278 case AL_AIR_ABSORPTION_FACTOR:
279 case AL_ROOM_ROLLOFF_FACTOR:
280 case AL_DIRECT_FILTER_GAINHF_AUTO:
281 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
282 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
283 case AL_DIRECT_CHANNELS_SOFT:
284 case AL_DISTANCE_MODEL:
285 case AL_SOURCE_RELATIVE:
286 case AL_LOOPING:
287 case AL_SOURCE_STATE:
288 case AL_BUFFERS_QUEUED:
289 case AL_BUFFERS_PROCESSED:
290 case AL_SOURCE_TYPE:
291 case AL_SOURCE_RADIUS:
292 case AL_SOURCE_RESAMPLER_SOFT:
293 case AL_SOURCE_SPATIALIZE_SOFT:
294 return 1;
295
296 case AL_STEREO_ANGLES:
297 return 2;
298
299 case AL_POSITION:
300 case AL_VELOCITY:
301 case AL_DIRECTION:
302 return 3;
303
304 case AL_ORIENTATION:
305 return 6;
306
307 case AL_SEC_OFFSET_LATENCY_SOFT:
308 case AL_SEC_OFFSET_CLOCK_SOFT:
309 break; /* Double only */
310
311 case AL_BUFFER:
312 case AL_DIRECT_FILTER:
313 case AL_AUXILIARY_SEND_FILTER:
314 break; /* i/i64 only */
315 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
316 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
317 break; /* i64 only */
318 }
319 return 0;
320 }
321 static ALint DoubleValsByProp(ALenum prop)
322 {
323 if(prop != (ALenum)((SourceProp)prop))
324 return 0;
325 switch((SourceProp)prop)
326 {
327 case AL_PITCH:
328 case AL_GAIN:
329 case AL_MIN_GAIN:
330 case AL_MAX_GAIN:
331 case AL_MAX_DISTANCE:
332 case AL_ROLLOFF_FACTOR:
333 case AL_DOPPLER_FACTOR:
334 case AL_CONE_OUTER_GAIN:
335 case AL_SEC_OFFSET:
336 case AL_SAMPLE_OFFSET:
337 case AL_BYTE_OFFSET:
338 case AL_CONE_INNER_ANGLE:
339 case AL_CONE_OUTER_ANGLE:
340 case AL_REFERENCE_DISTANCE:
341 case AL_CONE_OUTER_GAINHF:
342 case AL_AIR_ABSORPTION_FACTOR:
343 case AL_ROOM_ROLLOFF_FACTOR:
344 case AL_DIRECT_FILTER_GAINHF_AUTO:
345 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
346 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
347 case AL_DIRECT_CHANNELS_SOFT:
348 case AL_DISTANCE_MODEL:
349 case AL_SOURCE_RELATIVE:
350 case AL_LOOPING:
351 case AL_SOURCE_STATE:
352 case AL_BUFFERS_QUEUED:
353 case AL_BUFFERS_PROCESSED:
354 case AL_SOURCE_TYPE:
355 case AL_SOURCE_RADIUS:
356 case AL_SOURCE_RESAMPLER_SOFT:
357 case AL_SOURCE_SPATIALIZE_SOFT:
358 return 1;
359
360 case AL_SEC_OFFSET_LATENCY_SOFT:
361 case AL_SEC_OFFSET_CLOCK_SOFT:
362 case AL_STEREO_ANGLES:
363 return 2;
364
365 case AL_POSITION:
366 case AL_VELOCITY:
367 case AL_DIRECTION:
368 return 3;
369
370 case AL_ORIENTATION:
371 return 6;
372
373 case AL_BUFFER:
374 case AL_DIRECT_FILTER:
375 case AL_AUXILIARY_SEND_FILTER:
376 break; /* i/i64 only */
377 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
378 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
379 break; /* i64 only */
380 }
381 return 0;
382 }
383
384 static ALint IntValsByProp(ALenum prop)
385 {
386 if(prop != (ALenum)((SourceProp)prop))
387 return 0;
388 switch((SourceProp)prop)
389 {
390 case AL_PITCH:
391 case AL_GAIN:
392 case AL_MIN_GAIN:
393 case AL_MAX_GAIN:
394 case AL_MAX_DISTANCE:
395 case AL_ROLLOFF_FACTOR:
396 case AL_DOPPLER_FACTOR:
397 case AL_CONE_OUTER_GAIN:
398 case AL_SEC_OFFSET:
399 case AL_SAMPLE_OFFSET:
400 case AL_BYTE_OFFSET:
401 case AL_CONE_INNER_ANGLE:
402 case AL_CONE_OUTER_ANGLE:
403 case AL_REFERENCE_DISTANCE:
404 case AL_CONE_OUTER_GAINHF:
405 case AL_AIR_ABSORPTION_FACTOR:
406 case AL_ROOM_ROLLOFF_FACTOR:
407 case AL_DIRECT_FILTER_GAINHF_AUTO:
408 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
409 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
410 case AL_DIRECT_CHANNELS_SOFT:
411 case AL_DISTANCE_MODEL:
412 case AL_SOURCE_RELATIVE:
413 case AL_LOOPING:
414 case AL_BUFFER:
415 case AL_SOURCE_STATE:
416 case AL_BUFFERS_QUEUED:
417 case AL_BUFFERS_PROCESSED:
418 case AL_SOURCE_TYPE:
419 case AL_DIRECT_FILTER:
420 case AL_SOURCE_RADIUS:
421 case AL_SOURCE_RESAMPLER_SOFT:
422 case AL_SOURCE_SPATIALIZE_SOFT:
423 return 1;
424
425 case AL_POSITION:
426 case AL_VELOCITY:
427 case AL_DIRECTION:
428 case AL_AUXILIARY_SEND_FILTER:
429 return 3;
430
431 case AL_ORIENTATION:
432 return 6;
433
434 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
435 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
436 break; /* i64 only */
437 case AL_SEC_OFFSET_LATENCY_SOFT:
438 case AL_SEC_OFFSET_CLOCK_SOFT:
439 break; /* Double only */
440 case AL_STEREO_ANGLES:
441 break; /* Float/double only */
442 }
443 return 0;
444 }
445 static ALint Int64ValsByProp(ALenum prop)
446 {
447 if(prop != (ALenum)((SourceProp)prop))
448 return 0;
449 switch((SourceProp)prop)
450 {
451 case AL_PITCH:
452 case AL_GAIN:
453 case AL_MIN_GAIN:
454 case AL_MAX_GAIN:
455 case AL_MAX_DISTANCE:
456 case AL_ROLLOFF_FACTOR:
457 case AL_DOPPLER_FACTOR:
458 case AL_CONE_OUTER_GAIN:
459 case AL_SEC_OFFSET:
460 case AL_SAMPLE_OFFSET:
461 case AL_BYTE_OFFSET:
462 case AL_CONE_INNER_ANGLE:
463 case AL_CONE_OUTER_ANGLE:
464 case AL_REFERENCE_DISTANCE:
465 case AL_CONE_OUTER_GAINHF:
466 case AL_AIR_ABSORPTION_FACTOR:
467 case AL_ROOM_ROLLOFF_FACTOR:
468 case AL_DIRECT_FILTER_GAINHF_AUTO:
469 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
470 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
471 case AL_DIRECT_CHANNELS_SOFT:
472 case AL_DISTANCE_MODEL:
473 case AL_SOURCE_RELATIVE:
474 case AL_LOOPING:
475 case AL_BUFFER:
476 case AL_SOURCE_STATE:
477 case AL_BUFFERS_QUEUED:
478 case AL_BUFFERS_PROCESSED:
479 case AL_SOURCE_TYPE:
480 case AL_DIRECT_FILTER:
481 case AL_SOURCE_RADIUS:
482 case AL_SOURCE_RESAMPLER_SOFT:
483 case AL_SOURCE_SPATIALIZE_SOFT:
484 return 1;
485
486 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
487 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
488 return 2;
489
490 case AL_POSITION:
491 case AL_VELOCITY:
492 case AL_DIRECTION:
493 case AL_AUXILIARY_SEND_FILTER:
494 return 3;
495
496 case AL_ORIENTATION:
497 return 6;
498
499 case AL_SEC_OFFSET_LATENCY_SOFT:
500 case AL_SEC_OFFSET_CLOCK_SOFT:
501 break; /* Double only */
502 case AL_STEREO_ANGLES:
503 break; /* Float/double only */
504 }
505 return 0;
506 }
507
508
509 #define CHECKVAL(x) do { \
510 if(!(x)) \
511 { \
512 alSetError(Context, AL_INVALID_VALUE, "Value out of range"); \
513 return AL_FALSE; \
514 } \
515 } while(0)
516
517 #define DO_UPDATEPROPS() do { \
518 ALvoice *voice; \
519 if(SourceShouldUpdate(Source, Context) && \
520 (voice=GetSourceVoice(Source, Context)) != NULL) \
521 UpdateSourceProps(Source, voice, device->NumAuxSends, Context); \
522 else \
523 ATOMIC_FLAG_CLEAR(&Source->PropsClean, almemory_order_release); \
524 } while(0)
525
526 static ALboolean SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const ALfloat *values)
527 {
528 ALCdevice *device = Context->Device;
529 ALint ival;
530
531 switch(prop)
532 {
533 case AL_SEC_OFFSET_LATENCY_SOFT:
534 case AL_SEC_OFFSET_CLOCK_SOFT:
535 /* Query only */
536 SETERR_RETURN(Context, AL_INVALID_OPERATION, AL_FALSE,
537 "Setting read-only source property 0x%04x", prop);
538
539 case AL_PITCH:
540 CHECKVAL(*values >= 0.0f);
541
542 Source->Pitch = *values;
543 DO_UPDATEPROPS();
544 return AL_TRUE;
545
546 case AL_CONE_INNER_ANGLE:
547 CHECKVAL(*values >= 0.0f && *values <= 360.0f);
548
549 Source->InnerAngle = *values;
550 DO_UPDATEPROPS();
551 return AL_TRUE;
552
553 case AL_CONE_OUTER_ANGLE:
554 CHECKVAL(*values >= 0.0f && *values <= 360.0f);
555
556 Source->OuterAngle = *values;
557 DO_UPDATEPROPS();
558 return AL_TRUE;
559
560 case AL_GAIN:
561 CHECKVAL(*values >= 0.0f);
562
563 Source->Gain = *values;
564 DO_UPDATEPROPS();
565 return AL_TRUE;
566
567 case AL_MAX_DISTANCE:
568 CHECKVAL(*values >= 0.0f);
569
570 Source->MaxDistance = *values;
571 DO_UPDATEPROPS();
572 return AL_TRUE;
573
574 case AL_ROLLOFF_FACTOR:
575 CHECKVAL(*values >= 0.0f);
576
577 Source->RolloffFactor = *values;
578 DO_UPDATEPROPS();
579 return AL_TRUE;
580
581 case AL_REFERENCE_DISTANCE:
582 CHECKVAL(*values >= 0.0f);
583
584 Source->RefDistance = *values;
585 DO_UPDATEPROPS();
586 return AL_TRUE;
587
588 case AL_MIN_GAIN:
589 CHECKVAL(*values >= 0.0f);
590
591 Source->MinGain = *values;
592 DO_UPDATEPROPS();
593 return AL_TRUE;
594
595 case AL_MAX_GAIN:
596 CHECKVAL(*values >= 0.0f);
597
598 Source->MaxGain = *values;
599 DO_UPDATEPROPS();
600 return AL_TRUE;
601
602 case AL_CONE_OUTER_GAIN:
603 CHECKVAL(*values >= 0.0f && *values <= 1.0f);
604
605 Source->OuterGain = *values;
606 DO_UPDATEPROPS();
607 return AL_TRUE;
608
609 case AL_CONE_OUTER_GAINHF:
610 CHECKVAL(*values >= 0.0f && *values <= 1.0f);
611
612 Source->OuterGainHF = *values;
613 DO_UPDATEPROPS();
614 return AL_TRUE;
615
616 case AL_AIR_ABSORPTION_FACTOR:
617 CHECKVAL(*values >= 0.0f && *values <= 10.0f);
618
619 Source->AirAbsorptionFactor = *values;
620 DO_UPDATEPROPS();
621 return AL_TRUE;
622
623 case AL_ROOM_ROLLOFF_FACTOR:
624 CHECKVAL(*values >= 0.0f && *values <= 10.0f);
625
626 Source->RoomRolloffFactor = *values;
627 DO_UPDATEPROPS();
628 return AL_TRUE;
629
630 case AL_DOPPLER_FACTOR:
631 CHECKVAL(*values >= 0.0f && *values <= 1.0f);
632
633 Source->DopplerFactor = *values;
634 DO_UPDATEPROPS();
635 return AL_TRUE;
636
637 case AL_SEC_OFFSET:
638 case AL_SAMPLE_OFFSET:
639 case AL_BYTE_OFFSET:
640 CHECKVAL(*values >= 0.0f);
641
642 Source->OffsetType = prop;
643 Source->Offset = *values;
644
645 if(IsPlayingOrPaused(Source))
646 {
647 ALvoice *voice;
648
649 ALCdevice_Lock(Context->Device);
650 /* Double-check that the source is still playing while we have
651 * the lock.
652 */
653 voice = GetSourceVoice(Source, Context);
654 if(voice)
655 {
656 if(ApplyOffset(Source, voice) == AL_FALSE)
657 {
658 ALCdevice_Unlock(Context->Device);
659 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid offset");
660 }
661 }
662 ALCdevice_Unlock(Context->Device);
663 }
664 return AL_TRUE;
665
666 case AL_SOURCE_RADIUS:
667 CHECKVAL(*values >= 0.0f && isfinite(*values));
668
669 Source->Radius = *values;
670 DO_UPDATEPROPS();
671 return AL_TRUE;
672
673 case AL_STEREO_ANGLES:
674 CHECKVAL(isfinite(values[0]) && isfinite(values[1]));
675
676 Source->StereoPan[0] = values[0];
677 Source->StereoPan[1] = values[1];
678 DO_UPDATEPROPS();
679 return AL_TRUE;
680
681
682 case AL_POSITION:
683 CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
684
685 Source->Position[0] = values[0];
686 Source->Position[1] = values[1];
687 Source->Position[2] = values[2];
688 DO_UPDATEPROPS();
689 return AL_TRUE;
690
691 case AL_VELOCITY:
692 CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
693
694 Source->Velocity[0] = values[0];
695 Source->Velocity[1] = values[1];
696 Source->Velocity[2] = values[2];
697 DO_UPDATEPROPS();
698 return AL_TRUE;
699
700 case AL_DIRECTION:
701 CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]));
702
703 Source->Direction[0] = values[0];
704 Source->Direction[1] = values[1];
705 Source->Direction[2] = values[2];
706 DO_UPDATEPROPS();
707 return AL_TRUE;
708
709 case AL_ORIENTATION:
710 CHECKVAL(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]) &&
711 isfinite(values[3]) && isfinite(values[4]) && isfinite(values[5]));
712
713 Source->Orientation[0][0] = values[0];
714 Source->Orientation[0][1] = values[1];
715 Source->Orientation[0][2] = values[2];
716 Source->Orientation[1][0] = values[3];
717 Source->Orientation[1][1] = values[4];
718 Source->Orientation[1][2] = values[5];
719 DO_UPDATEPROPS();
720 return AL_TRUE;
721
722
723 case AL_SOURCE_RELATIVE:
724 case AL_LOOPING:
725 case AL_SOURCE_STATE:
726 case AL_SOURCE_TYPE:
727 case AL_DISTANCE_MODEL:
728 case AL_DIRECT_FILTER_GAINHF_AUTO:
729 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
730 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
731 case AL_DIRECT_CHANNELS_SOFT:
732 case AL_SOURCE_RESAMPLER_SOFT:
733 case AL_SOURCE_SPATIALIZE_SOFT:
734 ival = (ALint)values[0];
735 return SetSourceiv(Source, Context, prop, &ival);
736
737 case AL_BUFFERS_QUEUED:
738 case AL_BUFFERS_PROCESSED:
739 ival = (ALint)((ALuint)values[0]);
740 return SetSourceiv(Source, Context, prop, &ival);
741
742 case AL_BUFFER:
743 case AL_DIRECT_FILTER:
744 case AL_AUXILIARY_SEND_FILTER:
745 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
746 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
747 break;
748 }
749
750 ERR("Unexpected property: 0x%04x\n", prop);
751 SETERR_RETURN(Context, AL_INVALID_ENUM, AL_FALSE, "Invalid source float property 0x%04x", prop);
752 }
753
754 static ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const ALint *values)
755 {
756 ALCdevice *device = Context->Device;
757 ALbuffer *buffer = NULL;
758 ALfilter *filter = NULL;
759 ALeffectslot *slot = NULL;
760 ALbufferlistitem *oldlist;
761 ALfloat fvals[6];
762
763 switch(prop)
764 {
765 case AL_SOURCE_STATE:
766 case AL_SOURCE_TYPE:
767 case AL_BUFFERS_QUEUED:
768 case AL_BUFFERS_PROCESSED:
769 /* Query only */
770 SETERR_RETURN(Context, AL_INVALID_OPERATION, AL_FALSE,
771 "Setting read-only source property 0x%04x", prop);
772
773 case AL_SOURCE_RELATIVE:
774 CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
775
776 Source->HeadRelative = (ALboolean)*values;
777 DO_UPDATEPROPS();
778 return AL_TRUE;
779
780 case AL_LOOPING:
781 CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
782
783 Source->Looping = (ALboolean)*values;
784 if(IsPlayingOrPaused(Source))
785 {
786 ALvoice *voice = GetSourceVoice(Source, Context);
787 if(voice)
788 {
789 if(Source->Looping)
790 ATOMIC_STORE(&voice->loop_buffer, Source->queue, almemory_order_release);
791 else
792 ATOMIC_STORE(&voice->loop_buffer, NULL, almemory_order_release);
793
794 /* If the source is playing, wait for the current mix to finish
795 * to ensure it isn't currently looping back or reaching the
796 * end.
797 */
798 while((ATOMIC_LOAD(&device->MixCount, almemory_order_acquire)&1))
799 althrd_yield();
800 }
801 }
802 return AL_TRUE;
803
804 case AL_BUFFER:
805 LockBufferList(device);
806 if(!(*values == 0 || (buffer=LookupBuffer(device, *values)) != NULL))
807 {
808 UnlockBufferList(device);
809 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid buffer ID %u",
810 *values);
811 }
812
813 if(buffer && buffer->MappedAccess != 0 &&
814 !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
815 {
816 UnlockBufferList(device);
817 SETERR_RETURN(Context, AL_INVALID_OPERATION, AL_FALSE,
818 "Setting non-persistently mapped buffer %u", buffer->id);
819 }
820 else
821 {
822 ALenum state = GetSourceState(Source, GetSourceVoice(Source, Context));
823 if(state == AL_PLAYING || state == AL_PAUSED)
824 {
825 UnlockBufferList(device);
826 SETERR_RETURN(Context, AL_INVALID_OPERATION, AL_FALSE,
827 "Setting buffer on playing or paused source %u", Source->id);
828 }
829 }
830
831 oldlist = Source->queue;
832 if(buffer != NULL)
833 {
834 /* Add the selected buffer to a one-item queue */
835 ALbufferlistitem *newlist = al_calloc(DEF_ALIGN,
836 FAM_SIZE(ALbufferlistitem, buffers, 1));
837 ATOMIC_INIT(&newlist->next, NULL);
838 newlist->num_buffers = 1;
839 newlist->buffers[0] = buffer;
840 IncrementRef(&buffer->ref);
841
842 /* Source is now Static */
843 Source->SourceType = AL_STATIC;
844 Source->queue = newlist;
845 }
846 else
847 {
848 /* Source is now Undetermined */
849 Source->SourceType = AL_UNDETERMINED;
850 Source->queue = NULL;
851 }
852 UnlockBufferList(device);
853
854 /* Delete all elements in the previous queue */
855 while(oldlist != NULL)
856 {
857 ALsizei i;
858 ALbufferlistitem *temp = oldlist;
859 oldlist = ATOMIC_LOAD(&temp->next, almemory_order_relaxed);
860
861 for(i = 0;i < temp->num_buffers;i++)
862 {
863 if(temp->buffers[i])
864 DecrementRef(&temp->buffers[i]->ref);
865 }
866 al_free(temp);
867 }
868 return AL_TRUE;
869
870 case AL_SEC_OFFSET:
871 case AL_SAMPLE_OFFSET:
872 case AL_BYTE_OFFSET:
873 CHECKVAL(*values >= 0);
874
875 Source->OffsetType = prop;
876 Source->Offset = *values;
877
878 if(IsPlayingOrPaused(Source))
879 {
880 ALvoice *voice;
881
882 ALCdevice_Lock(Context->Device);
883 voice = GetSourceVoice(Source, Context);
884 if(voice)
885 {
886 if(ApplyOffset(Source, voice) == AL_FALSE)
887 {
888 ALCdevice_Unlock(Context->Device);
889 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE,
890 "Invalid source offset");
891 }
892 }
893 ALCdevice_Unlock(Context->Device);
894 }
895 return AL_TRUE;
896
897 case AL_DIRECT_FILTER:
898 LockFilterList(device);
899 if(!(*values == 0 || (filter=LookupFilter(device, *values)) != NULL))
900 {
901 UnlockFilterList(device);
902 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid filter ID %u",
903 *values);
904 }
905
906 if(!filter)
907 {
908 Source->Direct.Gain = 1.0f;
909 Source->Direct.GainHF = 1.0f;
910 Source->Direct.HFReference = LOWPASSFREQREF;
911 Source->Direct.GainLF = 1.0f;
912 Source->Direct.LFReference = HIGHPASSFREQREF;
913 }
914 else
915 {
916 Source->Direct.Gain = filter->Gain;
917 Source->Direct.GainHF = filter->GainHF;
918 Source->Direct.HFReference = filter->HFReference;
919 Source->Direct.GainLF = filter->GainLF;
920 Source->Direct.LFReference = filter->LFReference;
921 }
922 UnlockFilterList(device);
923 DO_UPDATEPROPS();
924 return AL_TRUE;
925
926 case AL_DIRECT_FILTER_GAINHF_AUTO:
927 CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
928
929 Source->DryGainHFAuto = *values;
930 DO_UPDATEPROPS();
931 return AL_TRUE;
932
933 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
934 CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
935
936 Source->WetGainAuto = *values;
937 DO_UPDATEPROPS();
938 return AL_TRUE;
939
940 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
941 CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
942
943 Source->WetGainHFAuto = *values;
944 DO_UPDATEPROPS();
945 return AL_TRUE;
946
947 case AL_DIRECT_CHANNELS_SOFT:
948 CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
949
950 Source->DirectChannels = *values;
951 DO_UPDATEPROPS();
952 return AL_TRUE;
953
954 case AL_DISTANCE_MODEL:
955 CHECKVAL(*values == AL_NONE ||
956 *values == AL_INVERSE_DISTANCE ||
957 *values == AL_INVERSE_DISTANCE_CLAMPED ||
958 *values == AL_LINEAR_DISTANCE ||
959 *values == AL_LINEAR_DISTANCE_CLAMPED ||
960 *values == AL_EXPONENT_DISTANCE ||
961 *values == AL_EXPONENT_DISTANCE_CLAMPED);
962
963 Source->DistanceModel = *values;
964 if(Context->SourceDistanceModel)
965 DO_UPDATEPROPS();
966 return AL_TRUE;
967
968 case AL_SOURCE_RESAMPLER_SOFT:
969 CHECKVAL(*values >= 0 && *values <= ResamplerMax);
970
971 Source->Resampler = *values;
972 DO_UPDATEPROPS();
973 return AL_TRUE;
974
975 case AL_SOURCE_SPATIALIZE_SOFT:
976 CHECKVAL(*values >= AL_FALSE && *values <= AL_AUTO_SOFT);
977
978 Source->Spatialize = *values;
979 DO_UPDATEPROPS();
980 return AL_TRUE;
981
982
983 case AL_AUXILIARY_SEND_FILTER:
984 LockEffectSlotList(Context);
985 if(!(values[0] == 0 || (slot=LookupEffectSlot(Context, values[0])) != NULL))
986 {
987 UnlockEffectSlotList(Context);
988 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid effect ID %u",
989 values[0]);
990 }
991 if(!((ALuint)values[1] < (ALuint)device->NumAuxSends))
992 {
993 UnlockEffectSlotList(Context);
994 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid send %u", values[1]);
995 }
996 LockFilterList(device);
997 if(!(values[2] == 0 || (filter=LookupFilter(device, values[2])) != NULL))
998 {
999 UnlockFilterList(device);
1000 UnlockEffectSlotList(Context);
1001 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid filter ID %u",
1002 values[2]);
1003 }
1004
1005 if(!filter)
1006 {
1007 /* Disable filter */
1008 Source->Send[values[1]].Gain = 1.0f;
1009 Source->Send[values[1]].GainHF = 1.0f;
1010 Source->Send[values[1]].HFReference = LOWPASSFREQREF;
1011 Source->Send[values[1]].GainLF = 1.0f;
1012 Source->Send[values[1]].LFReference = HIGHPASSFREQREF;
1013 }
1014 else
1015 {
1016 Source->Send[values[1]].Gain = filter->Gain;
1017 Source->Send[values[1]].GainHF = filter->GainHF;
1018 Source->Send[values[1]].HFReference = filter->HFReference;
1019 Source->Send[values[1]].GainLF = filter->GainLF;
1020 Source->Send[values[1]].LFReference = filter->LFReference;
1021 }
1022 UnlockFilterList(device);
1023
1024 if(slot != Source->Send[values[1]].Slot && IsPlayingOrPaused(Source))
1025 {
1026 ALvoice *voice;
1027 /* Add refcount on the new slot, and release the previous slot */
1028 if(slot) IncrementRef(&slot->ref);
1029 if(Source->Send[values[1]].Slot)
1030 DecrementRef(&Source->Send[values[1]].Slot->ref);
1031 Source->Send[values[1]].Slot = slot;
1032
1033 /* We must force an update if the auxiliary slot changed on an
1034 * active source, in case the slot is about to be deleted.
1035 */
1036 if((voice=GetSourceVoice(Source, Context)) != NULL)
1037 UpdateSourceProps(Source, voice, device->NumAuxSends, Context);
1038 else
1039 ATOMIC_FLAG_CLEAR(&Source->PropsClean, almemory_order_release);
1040 }
1041 else
1042 {
1043 if(slot) IncrementRef(&slot->ref);
1044 if(Source->Send[values[1]].Slot)
1045 DecrementRef(&Source->Send[values[1]].Slot->ref);
1046 Source->Send[values[1]].Slot = slot;
1047 DO_UPDATEPROPS();
1048 }
1049 UnlockEffectSlotList(Context);
1050
1051 return AL_TRUE;
1052
1053
1054 /* 1x float */
1055 case AL_CONE_INNER_ANGLE:
1056 case AL_CONE_OUTER_ANGLE:
1057 case AL_PITCH:
1058 case AL_GAIN:
1059 case AL_MIN_GAIN:
1060 case AL_MAX_GAIN:
1061 case AL_REFERENCE_DISTANCE:
1062 case AL_ROLLOFF_FACTOR:
1063 case AL_CONE_OUTER_GAIN:
1064 case AL_MAX_DISTANCE:
1065 case AL_DOPPLER_FACTOR:
1066 case AL_CONE_OUTER_GAINHF:
1067 case AL_AIR_ABSORPTION_FACTOR:
1068 case AL_ROOM_ROLLOFF_FACTOR:
1069 case AL_SOURCE_RADIUS:
1070 fvals[0] = (ALfloat)*values;
1071 return SetSourcefv(Source, Context, (int)prop, fvals);
1072
1073 /* 3x float */
1074 case AL_POSITION:
1075 case AL_VELOCITY:
1076 case AL_DIRECTION:
1077 fvals[0] = (ALfloat)values[0];
1078 fvals[1] = (ALfloat)values[1];
1079 fvals[2] = (ALfloat)values[2];
1080 return SetSourcefv(Source, Context, (int)prop, fvals);
1081
1082 /* 6x float */
1083 case AL_ORIENTATION:
1084 fvals[0] = (ALfloat)values[0];
1085 fvals[1] = (ALfloat)values[1];
1086 fvals[2] = (ALfloat)values[2];
1087 fvals[3] = (ALfloat)values[3];
1088 fvals[4] = (ALfloat)values[4];
1089 fvals[5] = (ALfloat)values[5];
1090 return SetSourcefv(Source, Context, (int)prop, fvals);
1091
1092 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1093 case AL_SEC_OFFSET_LATENCY_SOFT:
1094 case AL_SEC_OFFSET_CLOCK_SOFT:
1095 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1096 case AL_STEREO_ANGLES:
1097 break;
1098 }
1099
1100 ERR("Unexpected property: 0x%04x\n", prop);
1101 SETERR_RETURN(Context, AL_INVALID_ENUM, AL_FALSE, "Invalid source integer property 0x%04x",
1102 prop);
1103 }
1104
1105 static ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const ALint64SOFT *values)
1106 {
1107 ALfloat fvals[6];
1108 ALint ivals[3];
1109
1110 switch(prop)
1111 {
1112 case AL_SOURCE_TYPE:
1113 case AL_BUFFERS_QUEUED:
1114 case AL_BUFFERS_PROCESSED:
1115 case AL_SOURCE_STATE:
1116 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1117 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1118 /* Query only */
1119 SETERR_RETURN(Context, AL_INVALID_OPERATION, AL_FALSE,
1120 "Setting read-only source property 0x%04x", prop);
1121
1122 /* 1x int */
1123 case AL_SOURCE_RELATIVE:
1124 case AL_LOOPING:
1125 case AL_SEC_OFFSET:
1126 case AL_SAMPLE_OFFSET:
1127 case AL_BYTE_OFFSET:
1128 case AL_DIRECT_FILTER_GAINHF_AUTO:
1129 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1130 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1131 case AL_DIRECT_CHANNELS_SOFT:
1132 case AL_DISTANCE_MODEL:
1133 case AL_SOURCE_RESAMPLER_SOFT:
1134 case AL_SOURCE_SPATIALIZE_SOFT:
1135 CHECKVAL(*values <= INT_MAX && *values >= INT_MIN);
1136
1137 ivals[0] = (ALint)*values;
1138 return SetSourceiv(Source, Context, (int)prop, ivals);
1139
1140 /* 1x uint */
1141 case AL_BUFFER:
1142 case AL_DIRECT_FILTER:
1143 CHECKVAL(*values <= UINT_MAX && *values >= 0);
1144
1145 ivals[0] = (ALuint)*values;
1146 return SetSourceiv(Source, Context, (int)prop, ivals);
1147
1148 /* 3x uint */
1149 case AL_AUXILIARY_SEND_FILTER:
1150 CHECKVAL(values[0] <= UINT_MAX && values[0] >= 0 &&
1151 values[1] <= UINT_MAX && values[1] >= 0 &&
1152 values[2] <= UINT_MAX && values[2] >= 0);
1153
1154 ivals[0] = (ALuint)values[0];
1155 ivals[1] = (ALuint)values[1];
1156 ivals[2] = (ALuint)values[2];
1157 return SetSourceiv(Source, Context, (int)prop, ivals);
1158
1159 /* 1x float */
1160 case AL_CONE_INNER_ANGLE:
1161 case AL_CONE_OUTER_ANGLE:
1162 case AL_PITCH:
1163 case AL_GAIN:
1164 case AL_MIN_GAIN:
1165 case AL_MAX_GAIN:
1166 case AL_REFERENCE_DISTANCE:
1167 case AL_ROLLOFF_FACTOR:
1168 case AL_CONE_OUTER_GAIN:
1169 case AL_MAX_DISTANCE:
1170 case AL_DOPPLER_FACTOR:
1171 case AL_CONE_OUTER_GAINHF:
1172 case AL_AIR_ABSORPTION_FACTOR:
1173 case AL_ROOM_ROLLOFF_FACTOR:
1174 case AL_SOURCE_RADIUS:
1175 fvals[0] = (ALfloat)*values;
1176 return SetSourcefv(Source, Context, (int)prop, fvals);
1177
1178 /* 3x float */
1179 case AL_POSITION:
1180 case AL_VELOCITY:
1181 case AL_DIRECTION:
1182 fvals[0] = (ALfloat)values[0];
1183 fvals[1] = (ALfloat)values[1];
1184 fvals[2] = (ALfloat)values[2];
1185 return SetSourcefv(Source, Context, (int)prop, fvals);
1186
1187 /* 6x float */
1188 case AL_ORIENTATION:
1189 fvals[0] = (ALfloat)values[0];
1190 fvals[1] = (ALfloat)values[1];
1191 fvals[2] = (ALfloat)values[2];
1192 fvals[3] = (ALfloat)values[3];
1193 fvals[4] = (ALfloat)values[4];
1194 fvals[5] = (ALfloat)values[5];
1195 return SetSourcefv(Source, Context, (int)prop, fvals);
1196
1197 case AL_SEC_OFFSET_LATENCY_SOFT:
1198 case AL_SEC_OFFSET_CLOCK_SOFT:
1199 case AL_STEREO_ANGLES:
1200 break;
1201 }
1202
1203 ERR("Unexpected property: 0x%04x\n", prop);
1204 SETERR_RETURN(Context, AL_INVALID_ENUM, AL_FALSE, "Invalid source integer64 property 0x%04x",
1205 prop);
1206 }
1207
1208 #undef CHECKVAL
1209
1210
1211 static ALboolean GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, ALdouble *values)
1212 {
1213 ALCdevice *device = Context->Device;
1214 ClockLatency clocktime;
1215 ALuint64 srcclock;
1216 ALint ivals[3];
1217 ALboolean err;
1218
1219 switch(prop)
1220 {
1221 case AL_GAIN:
1222 *values = Source->Gain;
1223 return AL_TRUE;
1224
1225 case AL_PITCH:
1226 *values = Source->Pitch;
1227 return AL_TRUE;
1228
1229 case AL_MAX_DISTANCE:
1230 *values = Source->MaxDistance;
1231 return AL_TRUE;
1232
1233 case AL_ROLLOFF_FACTOR:
1234 *values = Source->RolloffFactor;
1235 return AL_TRUE;
1236
1237 case AL_REFERENCE_DISTANCE:
1238 *values = Source->RefDistance;
1239 return AL_TRUE;
1240
1241 case AL_CONE_INNER_ANGLE:
1242 *values = Source->InnerAngle;
1243 return AL_TRUE;
1244
1245 case AL_CONE_OUTER_ANGLE:
1246 *values = Source->OuterAngle;
1247 return AL_TRUE;
1248
1249 case AL_MIN_GAIN:
1250 *values = Source->MinGain;
1251 return AL_TRUE;
1252
1253 case AL_MAX_GAIN:
1254 *values = Source->MaxGain;
1255 return AL_TRUE;
1256
1257 case AL_CONE_OUTER_GAIN:
1258 *values = Source->OuterGain;
1259 return AL_TRUE;
1260
1261 case AL_SEC_OFFSET:
1262 case AL_SAMPLE_OFFSET:
1263 case AL_BYTE_OFFSET:
1264 *values = GetSourceOffset(Source, prop, Context);
1265 return AL_TRUE;
1266
1267 case AL_CONE_OUTER_GAINHF:
1268 *values = Source->OuterGainHF;
1269 return AL_TRUE;
1270
1271 case AL_AIR_ABSORPTION_FACTOR:
1272 *values = Source->AirAbsorptionFactor;
1273 return AL_TRUE;
1274
1275 case AL_ROOM_ROLLOFF_FACTOR:
1276 *values = Source->RoomRolloffFactor;
1277 return AL_TRUE;
1278
1279 case AL_DOPPLER_FACTOR:
1280 *values = Source->DopplerFactor;
1281 return AL_TRUE;
1282
1283 case AL_SOURCE_RADIUS:
1284 *values = Source->Radius;
1285 return AL_TRUE;
1286
1287 case AL_STEREO_ANGLES:
1288 values[0] = Source->StereoPan[0];
1289 values[1] = Source->StereoPan[1];
1290 return AL_TRUE;
1291
1292 case AL_SEC_OFFSET_LATENCY_SOFT:
1293 /* Get the source offset with the clock time first. Then get the
1294 * clock time with the device latency. Order is important.
1295 */
1296 values[0] = GetSourceSecOffset(Source, Context, &srcclock);
1297 almtx_lock(&device->BackendLock);
1298 clocktime = V0(device->Backend,getClockLatency)();
1299 almtx_unlock(&device->BackendLock);
1300 if(srcclock == (ALuint64)clocktime.ClockTime)
1301 values[1] = (ALdouble)clocktime.Latency / 1000000000.0;
1302 else
1303 {
1304 /* If the clock time incremented, reduce the latency by that
1305 * much since it's that much closer to the source offset it got
1306 * earlier.
1307 */
1308 ALuint64 diff = clocktime.ClockTime - srcclock;
1309 values[1] = (ALdouble)(clocktime.Latency - minu64(clocktime.Latency, diff)) /
1310 1000000000.0;
1311 }
1312 return AL_TRUE;
1313
1314 case AL_SEC_OFFSET_CLOCK_SOFT:
1315 values[0] = GetSourceSecOffset(Source, Context, &srcclock);
1316 values[1] = srcclock / 1000000000.0;
1317 return AL_TRUE;
1318
1319 case AL_POSITION:
1320 values[0] = Source->Position[0];
1321 values[1] = Source->Position[1];
1322 values[2] = Source->Position[2];
1323 return AL_TRUE;
1324
1325 case AL_VELOCITY:
1326 values[0] = Source->Velocity[0];
1327 values[1] = Source->Velocity[1];
1328 values[2] = Source->Velocity[2];
1329 return AL_TRUE;
1330
1331 case AL_DIRECTION:
1332 values[0] = Source->Direction[0];
1333 values[1] = Source->Direction[1];
1334 values[2] = Source->Direction[2];
1335 return AL_TRUE;
1336
1337 case AL_ORIENTATION:
1338 values[0] = Source->Orientation[0][0];
1339 values[1] = Source->Orientation[0][1];
1340 values[2] = Source->Orientation[0][2];
1341 values[3] = Source->Orientation[1][0];
1342 values[4] = Source->Orientation[1][1];
1343 values[5] = Source->Orientation[1][2];
1344 return AL_TRUE;
1345
1346 /* 1x int */
1347 case AL_SOURCE_RELATIVE:
1348 case AL_LOOPING:
1349 case AL_SOURCE_STATE:
1350 case AL_BUFFERS_QUEUED:
1351 case AL_BUFFERS_PROCESSED:
1352 case AL_SOURCE_TYPE:
1353 case AL_DIRECT_FILTER_GAINHF_AUTO:
1354 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1355 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1356 case AL_DIRECT_CHANNELS_SOFT:
1357 case AL_DISTANCE_MODEL:
1358 case AL_SOURCE_RESAMPLER_SOFT:
1359 case AL_SOURCE_SPATIALIZE_SOFT:
1360 if((err=GetSourceiv(Source, Context, (int)prop, ivals)) != AL_FALSE)
1361 *values = (ALdouble)ivals[0];
1362 return err;
1363
1364 case AL_BUFFER:
1365 case AL_DIRECT_FILTER:
1366 case AL_AUXILIARY_SEND_FILTER:
1367 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1368 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1369 break;
1370 }
1371
1372 ERR("Unexpected property: 0x%04x\n", prop);
1373 SETERR_RETURN(Context, AL_INVALID_ENUM, AL_FALSE, "Invalid source double property 0x%04x",
1374 prop);
1375 }
1376
1377 static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, ALint *values)
1378 {
1379 ALbufferlistitem *BufferList;
1380 ALdouble dvals[6];
1381 ALboolean err;
1382
1383 switch(prop)
1384 {
1385 case AL_SOURCE_RELATIVE:
1386 *values = Source->HeadRelative;
1387 return AL_TRUE;
1388
1389 case AL_LOOPING:
1390 *values = Source->Looping;
1391 return AL_TRUE;
1392
1393 case AL_BUFFER:
1394 BufferList = (Source->SourceType == AL_STATIC) ? Source->queue : NULL;
1395 *values = (BufferList && BufferList->num_buffers >= 1 && BufferList->buffers[0]) ?
1396 BufferList->buffers[0]->id : 0;
1397 return AL_TRUE;
1398
1399 case AL_SOURCE_STATE:
1400 *values = GetSourceState(Source, GetSourceVoice(Source, Context));
1401 return AL_TRUE;
1402
1403 case AL_BUFFERS_QUEUED:
1404 if(!(BufferList=Source->queue))
1405 *values = 0;
1406 else
1407 {
1408 ALsizei count = 0;
1409 do {
1410 count += BufferList->num_buffers;
1411 BufferList = ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed);
1412 } while(BufferList != NULL);
1413 *values = count;
1414 }
1415 return AL_TRUE;
1416
1417 case AL_BUFFERS_PROCESSED:
1418 if(Source->Looping || Source->SourceType != AL_STREAMING)
1419 {
1420 /* Buffers on a looping source are in a perpetual state of
1421 * PENDING, so don't report any as PROCESSED */
1422 *values = 0;
1423 }
1424 else
1425 {
1426 const ALbufferlistitem *BufferList = Source->queue;
1427 const ALbufferlistitem *Current = NULL;
1428 ALsizei played = 0;
1429 ALvoice *voice;
1430
1431 if((voice=GetSourceVoice(Source, Context)) != NULL)
1432 Current = ATOMIC_LOAD(&voice->current_buffer, almemory_order_relaxed);
1433 else if(Source->state == AL_INITIAL)
1434 Current = BufferList;
1435
1436 while(BufferList && BufferList != Current)
1437 {
1438 played += BufferList->num_buffers;
1439 BufferList = ATOMIC_LOAD(&CONST_CAST(ALbufferlistitem*,BufferList)->next,
1440 almemory_order_relaxed);
1441 }
1442 *values = played;
1443 }
1444 return AL_TRUE;
1445
1446 case AL_SOURCE_TYPE:
1447 *values = Source->SourceType;
1448 return AL_TRUE;
1449
1450 case AL_DIRECT_FILTER_GAINHF_AUTO:
1451 *values = Source->DryGainHFAuto;
1452 return AL_TRUE;
1453
1454 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1455 *values = Source->WetGainAuto;
1456 return AL_TRUE;
1457
1458 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1459 *values = Source->WetGainHFAuto;
1460 return AL_TRUE;
1461
1462 case AL_DIRECT_CHANNELS_SOFT:
1463 *values = Source->DirectChannels;
1464 return AL_TRUE;
1465
1466 case AL_DISTANCE_MODEL:
1467 *values = Source->DistanceModel;
1468 return AL_TRUE;
1469
1470 case AL_SOURCE_RESAMPLER_SOFT:
1471 *values = Source->Resampler;
1472 return AL_TRUE;
1473
1474 case AL_SOURCE_SPATIALIZE_SOFT:
1475 *values = Source->Spatialize;
1476 return AL_TRUE;
1477
1478 /* 1x float/double */
1479 case AL_CONE_INNER_ANGLE:
1480 case AL_CONE_OUTER_ANGLE:
1481 case AL_PITCH:
1482 case AL_GAIN:
1483 case AL_MIN_GAIN:
1484 case AL_MAX_GAIN:
1485 case AL_REFERENCE_DISTANCE:
1486 case AL_ROLLOFF_FACTOR:
1487 case AL_CONE_OUTER_GAIN:
1488 case AL_MAX_DISTANCE:
1489 case AL_SEC_OFFSET:
1490 case AL_SAMPLE_OFFSET:
1491 case AL_BYTE_OFFSET:
1492 case AL_DOPPLER_FACTOR:
1493 case AL_AIR_ABSORPTION_FACTOR:
1494 case AL_ROOM_ROLLOFF_FACTOR:
1495 case AL_CONE_OUTER_GAINHF:
1496 case AL_SOURCE_RADIUS:
1497 if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
1498 *values = (ALint)dvals[0];
1499 return err;
1500
1501 /* 3x float/double */
1502 case AL_POSITION:
1503 case AL_VELOCITY:
1504 case AL_DIRECTION:
1505 if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
1506 {
1507 values[0] = (ALint)dvals[0];
1508 values[1] = (ALint)dvals[1];
1509 values[2] = (ALint)dvals[2];
1510 }
1511 return err;
1512
1513 /* 6x float/double */
1514 case AL_ORIENTATION:
1515 if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
1516 {
1517 values[0] = (ALint)dvals[0];
1518 values[1] = (ALint)dvals[1];
1519 values[2] = (ALint)dvals[2];
1520 values[3] = (ALint)dvals[3];
1521 values[4] = (ALint)dvals[4];
1522 values[5] = (ALint)dvals[5];
1523 }
1524 return err;
1525
1526 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1527 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1528 break; /* i64 only */
1529 case AL_SEC_OFFSET_LATENCY_SOFT:
1530 case AL_SEC_OFFSET_CLOCK_SOFT:
1531 break; /* Double only */
1532 case AL_STEREO_ANGLES:
1533 break; /* Float/double only */
1534
1535 case AL_DIRECT_FILTER:
1536 case AL_AUXILIARY_SEND_FILTER:
1537 break; /* ??? */
1538 }
1539
1540 ERR("Unexpected property: 0x%04x\n", prop);
1541 SETERR_RETURN(Context, AL_INVALID_ENUM, AL_FALSE, "Invalid source integer property 0x%04x",
1542 prop);
1543 }
1544
1545 static ALboolean GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, ALint64 *values)
1546 {
1547 ALCdevice *device = Context->Device;
1548 ClockLatency clocktime;
1549 ALuint64 srcclock;
1550 ALdouble dvals[6];
1551 ALint ivals[3];
1552 ALboolean err;
1553
1554 switch(prop)
1555 {
1556 case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1557 /* Get the source offset with the clock time first. Then get the
1558 * clock time with the device latency. Order is important.
1559 */
1560 values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
1561 almtx_lock(&device->BackendLock);
1562 clocktime = V0(device->Backend,getClockLatency)();
1563 almtx_unlock(&device->BackendLock);
1564 if(srcclock == (ALuint64)clocktime.ClockTime)
1565 values[1] = clocktime.Latency;
1566 else
1567 {
1568 /* If the clock time incremented, reduce the latency by that
1569 * much since it's that much closer to the source offset it got
1570 * earlier.
1571 */
1572 ALuint64 diff = clocktime.ClockTime - srcclock;
1573 values[1] = clocktime.Latency - minu64(clocktime.Latency, diff);
1574 }
1575 return AL_TRUE;
1576
1577 case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1578 values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
1579 values[1] = srcclock;
1580 return AL_TRUE;
1581
1582 /* 1x float/double */
1583 case AL_CONE_INNER_ANGLE:
1584 case AL_CONE_OUTER_ANGLE:
1585 case AL_PITCH:
1586 case AL_GAIN:
1587 case AL_MIN_GAIN:
1588 case AL_MAX_GAIN:
1589 case AL_REFERENCE_DISTANCE:
1590 case AL_ROLLOFF_FACTOR:
1591 case AL_CONE_OUTER_GAIN:
1592 case AL_MAX_DISTANCE:
1593 case AL_SEC_OFFSET:
1594 case AL_SAMPLE_OFFSET:
1595 case AL_BYTE_OFFSET:
1596 case AL_DOPPLER_FACTOR:
1597 case AL_AIR_ABSORPTION_FACTOR:
1598 case AL_ROOM_ROLLOFF_FACTOR:
1599 case AL_CONE_OUTER_GAINHF:
1600 case AL_SOURCE_RADIUS:
1601 if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
1602 *values = (ALint64)dvals[0];
1603 return err;
1604
1605 /* 3x float/double */
1606 case AL_POSITION:
1607 case AL_VELOCITY:
1608 case AL_DIRECTION:
1609 if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
1610 {
1611 values[0] = (ALint64)dvals[0];
1612 values[1] = (ALint64)dvals[1];
1613 values[2] = (ALint64)dvals[2];
1614 }
1615 return err;
1616
1617 /* 6x float/double */
1618 case AL_ORIENTATION:
1619 if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
1620 {
1621 values[0] = (ALint64)dvals[0];
1622 values[1] = (ALint64)dvals[1];
1623 values[2] = (ALint64)dvals[2];
1624 values[3] = (ALint64)dvals[3];
1625 values[4] = (ALint64)dvals[4];
1626 values[5] = (ALint64)dvals[5];
1627 }
1628 return err;
1629
1630 /* 1x int */
1631 case AL_SOURCE_RELATIVE:
1632 case AL_LOOPING:
1633 case AL_SOURCE_STATE:
1634 case AL_BUFFERS_QUEUED:
1635 case AL_BUFFERS_PROCESSED:
1636 case AL_SOURCE_TYPE:
1637 case AL_DIRECT_FILTER_GAINHF_AUTO:
1638 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1639 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1640 case AL_DIRECT_CHANNELS_SOFT:
1641 case AL_DISTANCE_MODEL:
1642 case AL_SOURCE_RESAMPLER_SOFT:
1643 case AL_SOURCE_SPATIALIZE_SOFT:
1644 if((err=GetSourceiv(Source, Context, prop, ivals)) != AL_FALSE)
1645 *values = ivals[0];
1646 return err;
1647
1648 /* 1x uint */
1649 case AL_BUFFER:
1650 case AL_DIRECT_FILTER:
1651 if((err=GetSourceiv(Source, Context, prop, ivals)) != AL_FALSE)
1652 *values = (ALuint)ivals[0];
1653 return err;
1654
1655 /* 3x uint */
1656 case AL_AUXILIARY_SEND_FILTER:
1657 if((err=GetSourceiv(Source, Context, prop, ivals)) != AL_FALSE)
1658 {
1659 values[0] = (ALuint)ivals[0];
1660 values[1] = (ALuint)ivals[1];
1661 values[2] = (ALuint)ivals[2];
1662 }
1663 return err;
1664
1665 case AL_SEC_OFFSET_LATENCY_SOFT:
1666 case AL_SEC_OFFSET_CLOCK_SOFT:
1667 break; /* Double only */
1668 case AL_STEREO_ANGLES:
1669 break; /* Float/double only */
1670 }
1671
1672 ERR("Unexpected property: 0x%04x\n", prop);
1673 SETERR_RETURN(Context, AL_INVALID_ENUM, AL_FALSE, "Invalid source integer64 property 0x%04x",
1674 prop);
1675 }
1676
1677
1678 AL_API ALvoid AL_APIENTRY alGenSources(ALsizei n, ALuint *sources)
1679 {
1680 ALCcontext *context;
1681 ALsizei cur = 0;
1682
1683 context = GetContextRef();
1684 if(!context) return;
1685
1686 if(!(n >= 0))
1687 alSetError(context, AL_INVALID_VALUE, "Generating %d sources", n);
1688 else for(cur = 0;cur < n;cur++)
1689 {
1690 ALsource *source = AllocSource(context);
1691 if(!source)
1692 {
1693 alDeleteSources(cur, sources);
1694 break;
1695 }
1696 sources[cur] = source->id;
1697 }
1698
1699 ALCcontext_DecRef(context);
1700 }
1701
1702
1703 AL_API ALvoid AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
1704 {
1705 ALCcontext *context;
1706 ALsource *Source;
1707 ALsizei i;
1708
1709 context = GetContextRef();
1710 if(!context) return;
1711
1712 LockSourceList(context);
1713 if(!(n >= 0))
1714 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Deleting %d sources", n);
1715
1716 /* Check that all Sources are valid */
1717 for(i = 0;i < n;i++)
1718 {
1719 if(LookupSource(context, sources[i]) == NULL)
1720 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", sources[i]);
1721 }
1722 for(i = 0;i < n;i++)
1723 {
1724 if((Source=LookupSource(context, sources[i])) != NULL)
1725 FreeSource(context, Source);
1726 }
1727
1728 done:
1729 UnlockSourceList(context);
1730 ALCcontext_DecRef(context);
1731 }
1732
1733
1734 AL_API ALboolean AL_APIENTRY alIsSource(ALuint source)
1735 {
1736 ALCcontext *context;
1737 ALboolean ret;
1738
1739 context = GetContextRef();
1740 if(!context) return AL_FALSE;
1741
1742 LockSourceList(context);
1743 ret = (LookupSource(context, source) ? AL_TRUE : AL_FALSE);
1744 UnlockSourceList(context);
1745
1746 ALCcontext_DecRef(context);
1747
1748 return ret;
1749 }
1750
1751
1752 AL_API ALvoid AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value)
1753 {
1754 ALCcontext *Context;
1755 ALsource *Source;
1756
1757 Context = GetContextRef();
1758 if(!Context) return;
1759
1760 almtx_lock(&Context->PropLock);
1761 LockSourceList(Context);
1762 if((Source=LookupSource(Context, source)) == NULL)
1763 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1764 else if(!(FloatValsByProp(param) == 1))
1765 alSetError(Context, AL_INVALID_ENUM, "Invalid float property 0x%04x", param);
1766 else
1767 SetSourcefv(Source, Context, param, &value);
1768 UnlockSourceList(Context);
1769 almtx_unlock(&Context->PropLock);
1770
1771 ALCcontext_DecRef(Context);
1772 }
1773
1774 AL_API ALvoid AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
1775 {
1776 ALCcontext *Context;
1777 ALsource *Source;
1778
1779 Context = GetContextRef();
1780 if(!Context) return;
1781
1782 almtx_lock(&Context->PropLock);
1783 LockSourceList(Context);
1784 if((Source=LookupSource(Context, source)) == NULL)
1785 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1786 else if(!(FloatValsByProp(param) == 3))
1787 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-float property 0x%04x", param);
1788 else
1789 {
1790 ALfloat fvals[3] = { value1, value2, value3 };
1791 SetSourcefv(Source, Context, param, fvals);
1792 }
1793 UnlockSourceList(Context);
1794 almtx_unlock(&Context->PropLock);
1795
1796 ALCcontext_DecRef(Context);
1797 }
1798
1799 AL_API ALvoid AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values)
1800 {
1801 ALCcontext *Context;
1802 ALsource *Source;
1803
1804 Context = GetContextRef();
1805 if(!Context) return;
1806
1807 almtx_lock(&Context->PropLock);
1808 LockSourceList(Context);
1809 if((Source=LookupSource(Context, source)) == NULL)
1810 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1811 else if(!values)
1812 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
1813 else if(!(FloatValsByProp(param) > 0))
1814 alSetError(Context, AL_INVALID_ENUM, "Invalid float-vector property 0x%04x", param);
1815 else
1816 SetSourcefv(Source, Context, param, values);
1817 UnlockSourceList(Context);
1818 almtx_unlock(&Context->PropLock);
1819
1820 ALCcontext_DecRef(Context);
1821 }
1822
1823
1824 AL_API ALvoid AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value)
1825 {
1826 ALCcontext *Context;
1827 ALsource *Source;
1828
1829 Context = GetContextRef();
1830 if(!Context) return;
1831
1832 almtx_lock(&Context->PropLock);
1833 LockSourceList(Context);
1834 if((Source=LookupSource(Context, source)) == NULL)
1835 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1836 else if(!(DoubleValsByProp(param) == 1))
1837 alSetError(Context, AL_INVALID_ENUM, "Invalid double property 0x%04x", param);
1838 else
1839 {
1840 ALfloat fval = (ALfloat)value;
1841 SetSourcefv(Source, Context, param, &fval);
1842 }
1843 UnlockSourceList(Context);
1844 almtx_unlock(&Context->PropLock);
1845
1846 ALCcontext_DecRef(Context);
1847 }
1848
1849 AL_API ALvoid AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3)
1850 {
1851 ALCcontext *Context;
1852 ALsource *Source;
1853
1854 Context = GetContextRef();
1855 if(!Context) return;
1856
1857 almtx_lock(&Context->PropLock);
1858 LockSourceList(Context);
1859 if((Source=LookupSource(Context, source)) == NULL)
1860 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1861 else if(!(DoubleValsByProp(param) == 3))
1862 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-double property 0x%04x", param);
1863 else
1864 {
1865 ALfloat fvals[3] = { (ALfloat)value1, (ALfloat)value2, (ALfloat)value3 };
1866 SetSourcefv(Source, Context, param, fvals);
1867 }
1868 UnlockSourceList(Context);
1869 almtx_unlock(&Context->PropLock);
1870
1871 ALCcontext_DecRef(Context);
1872 }
1873
1874 AL_API ALvoid AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values)
1875 {
1876 ALCcontext *Context;
1877 ALsource *Source;
1878 ALint count;
1879
1880 Context = GetContextRef();
1881 if(!Context) return;
1882
1883 almtx_lock(&Context->PropLock);
1884 LockSourceList(Context);
1885 if((Source=LookupSource(Context, source)) == NULL)
1886 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1887 else if(!values)
1888 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
1889 else if(!((count=DoubleValsByProp(param)) > 0 && count <= 6))
1890 alSetError(Context, AL_INVALID_ENUM, "Invalid double-vector property 0x%04x", param);
1891 else
1892 {
1893 ALfloat fvals[6];
1894 ALint i;
1895
1896 for(i = 0;i < count;i++)
1897 fvals[i] = (ALfloat)values[i];
1898 SetSourcefv(Source, Context, param, fvals);
1899 }
1900 UnlockSourceList(Context);
1901 almtx_unlock(&Context->PropLock);
1902
1903 ALCcontext_DecRef(Context);
1904 }
1905
1906
1907 AL_API ALvoid AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value)
1908 {
1909 ALCcontext *Context;
1910 ALsource *Source;
1911
1912 Context = GetContextRef();
1913 if(!Context) return;
1914
1915 almtx_lock(&Context->PropLock);
1916 LockSourceList(Context);
1917 if((Source=LookupSource(Context, source)) == NULL)
1918 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1919 else if(!(IntValsByProp(param) == 1))
1920 alSetError(Context, AL_INVALID_ENUM, "Invalid integer property 0x%04x", param);
1921 else
1922 SetSourceiv(Source, Context, param, &value);
1923 UnlockSourceList(Context);
1924 almtx_unlock(&Context->PropLock);
1925
1926 ALCcontext_DecRef(Context);
1927 }
1928
1929 AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3)
1930 {
1931 ALCcontext *Context;
1932 ALsource *Source;
1933
1934 Context = GetContextRef();
1935 if(!Context) return;
1936
1937 almtx_lock(&Context->PropLock);
1938 LockSourceList(Context);
1939 if((Source=LookupSource(Context, source)) == NULL)
1940 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1941 else if(!(IntValsByProp(param) == 3))
1942 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-integer property 0x%04x", param);
1943 else
1944 {
1945 ALint ivals[3] = { value1, value2, value3 };
1946 SetSourceiv(Source, Context, param, ivals);
1947 }
1948 UnlockSourceList(Context);
1949 almtx_unlock(&Context->PropLock);
1950
1951 ALCcontext_DecRef(Context);
1952 }
1953
1954 AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values)
1955 {
1956 ALCcontext *Context;
1957 ALsource *Source;
1958
1959 Context = GetContextRef();
1960 if(!Context) return;
1961
1962 almtx_lock(&Context->PropLock);
1963 LockSourceList(Context);
1964 if((Source=LookupSource(Context, source)) == NULL)
1965 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1966 else if(!values)
1967 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
1968 else if(!(IntValsByProp(param) > 0))
1969 alSetError(Context, AL_INVALID_ENUM, "Invalid integer-vector property 0x%04x", param);
1970 else
1971 SetSourceiv(Source, Context, param, values);
1972 UnlockSourceList(Context);
1973 almtx_unlock(&Context->PropLock);
1974
1975 ALCcontext_DecRef(Context);
1976 }
1977
1978
1979 AL_API ALvoid AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value)
1980 {
1981 ALCcontext *Context;
1982 ALsource *Source;
1983
1984 Context = GetContextRef();
1985 if(!Context) return;
1986
1987 almtx_lock(&Context->PropLock);
1988 LockSourceList(Context);
1989 if((Source=LookupSource(Context, source)) == NULL)
1990 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
1991 else if(!(Int64ValsByProp(param) == 1))
1992 alSetError(Context, AL_INVALID_ENUM, "Invalid integer64 property 0x%04x", param);
1993 else
1994 SetSourcei64v(Source, Context, param, &value);
1995 UnlockSourceList(Context);
1996 almtx_unlock(&Context->PropLock);
1997
1998 ALCcontext_DecRef(Context);
1999 }
2000
2001 AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3)
2002 {
2003 ALCcontext *Context;
2004 ALsource *Source;
2005
2006 Context = GetContextRef();
2007 if(!Context) return;
2008
2009 almtx_lock(&Context->PropLock);
2010 LockSourceList(Context);
2011 if((Source=LookupSource(Context, source)) == NULL)
2012 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2013 else if(!(Int64ValsByProp(param) == 3))
2014 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-integer64 property 0x%04x", param);
2015 else
2016 {
2017 ALint64SOFT i64vals[3] = { value1, value2, value3 };
2018 SetSourcei64v(Source, Context, param, i64vals);
2019 }
2020 UnlockSourceList(Context);
2021 almtx_unlock(&Context->PropLock);
2022
2023 ALCcontext_DecRef(Context);
2024 }
2025
2026 AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values)
2027 {
2028 ALCcontext *Context;
2029 ALsource *Source;
2030
2031 Context = GetContextRef();
2032 if(!Context) return;
2033
2034 almtx_lock(&Context->PropLock);
2035 LockSourceList(Context);
2036 if((Source=LookupSource(Context, source)) == NULL)
2037 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2038 else if(!values)
2039 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2040 else if(!(Int64ValsByProp(param) > 0))
2041 alSetError(Context, AL_INVALID_ENUM, "Invalid integer64-vector property 0x%04x", param);
2042 else
2043 SetSourcei64v(Source, Context, param, values);
2044 UnlockSourceList(Context);
2045 almtx_unlock(&Context->PropLock);
2046
2047 ALCcontext_DecRef(Context);
2048 }
2049
2050
2051 AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value)
2052 {
2053 ALCcontext *Context;
2054 ALsource *Source;
2055
2056 Context = GetContextRef();
2057 if(!Context) return;
2058
2059 LockSourceList(Context);
2060 if((Source=LookupSource(Context, source)) == NULL)
2061 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2062 else if(!value)
2063 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2064 else if(!(FloatValsByProp(param) == 1))
2065 alSetError(Context, AL_INVALID_ENUM, "Invalid float property 0x%04x", param);
2066 else
2067 {
2068 ALdouble dval;
2069 if(GetSourcedv(Source, Context, param, &dval))
2070 *value = (ALfloat)dval;
2071 }
2072 UnlockSourceList(Context);
2073
2074 ALCcontext_DecRef(Context);
2075 }
2076
2077
2078 AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
2079 {
2080 ALCcontext *Context;
2081 ALsource *Source;
2082
2083 Context = GetContextRef();
2084 if(!Context) return;
2085
2086 LockSourceList(Context);
2087 if((Source=LookupSource(Context, source)) == NULL)
2088 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2089 else if(!(value1 && value2 && value3))
2090 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2091 else if(!(FloatValsByProp(param) == 3))
2092 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-float property 0x%04x", param);
2093 else
2094 {
2095 ALdouble dvals[3];
2096 if(GetSourcedv(Source, Context, param, dvals))
2097 {
2098 *value1 = (ALfloat)dvals[0];
2099 *value2 = (ALfloat)dvals[1];
2100 *value3 = (ALfloat)dvals[2];
2101 }
2102 }
2103 UnlockSourceList(Context);
2104
2105 ALCcontext_DecRef(Context);
2106 }
2107
2108
2109 AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values)
2110 {
2111 ALCcontext *Context;
2112 ALsource *Source;
2113 ALint count;
2114
2115 Context = GetContextRef();
2116 if(!Context) return;
2117
2118 LockSourceList(Context);
2119 if((Source=LookupSource(Context, source)) == NULL)
2120 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2121 else if(!values)
2122 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2123 else if(!((count=FloatValsByProp(param)) > 0 && count <= 6))
2124 alSetError(Context, AL_INVALID_ENUM, "Invalid float-vector property 0x%04x", param);
2125 else
2126 {
2127 ALdouble dvals[6];
2128 if(GetSourcedv(Source, Context, param, dvals))
2129 {
2130 ALint i;
2131 for(i = 0;i < count;i++)
2132 values[i] = (ALfloat)dvals[i];
2133 }
2134 }
2135 UnlockSourceList(Context);
2136
2137 ALCcontext_DecRef(Context);
2138 }
2139
2140
2141 AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value)
2142 {
2143 ALCcontext *Context;
2144 ALsource *Source;
2145
2146 Context = GetContextRef();
2147 if(!Context) return;
2148
2149 LockSourceList(Context);
2150 if((Source=LookupSource(Context, source)) == NULL)
2151 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2152 else if(!value)
2153 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2154 else if(!(DoubleValsByProp(param) == 1))
2155 alSetError(Context, AL_INVALID_ENUM, "Invalid double property 0x%04x", param);
2156 else
2157 GetSourcedv(Source, Context, param, value);
2158 UnlockSourceList(Context);
2159
2160 ALCcontext_DecRef(Context);
2161 }
2162
2163 AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3)
2164 {
2165 ALCcontext *Context;
2166 ALsource *Source;
2167
2168 Context = GetContextRef();
2169 if(!Context) return;
2170
2171 LockSourceList(Context);
2172 if((Source=LookupSource(Context, source)) == NULL)
2173 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2174 else if(!(value1 && value2 && value3))
2175 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2176 else if(!(DoubleValsByProp(param) == 3))
2177 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-double property 0x%04x", param);
2178 else
2179 {
2180 ALdouble dvals[3];
2181 if(GetSourcedv(Source, Context, param, dvals))
2182 {
2183 *value1 = dvals[0];
2184 *value2 = dvals[1];
2185 *value3 = dvals[2];
2186 }
2187 }
2188 UnlockSourceList(Context);
2189
2190 ALCcontext_DecRef(Context);
2191 }
2192
2193 AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values)
2194 {
2195 ALCcontext *Context;
2196 ALsource *Source;
2197
2198 Context = GetContextRef();
2199 if(!Context) return;
2200
2201 LockSourceList(Context);
2202 if((Source=LookupSource(Context, source)) == NULL)
2203 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2204 else if(!values)
2205 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2206 else if(!(DoubleValsByProp(param) > 0))
2207 alSetError(Context, AL_INVALID_ENUM, "Invalid double-vector property 0x%04x", param);
2208 else
2209 GetSourcedv(Source, Context, param, values);
2210 UnlockSourceList(Context);
2211
2212 ALCcontext_DecRef(Context);
2213 }
2214
2215
2216 AL_API ALvoid AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value)
2217 {
2218 ALCcontext *Context;
2219 ALsource *Source;
2220
2221 Context = GetContextRef();
2222 if(!Context) return;
2223
2224 LockSourceList(Context);
2225 if((Source=LookupSource(Context, source)) == NULL)
2226 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2227 else if(!value)
2228 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2229 else if(!(IntValsByProp(param) == 1))
2230 alSetError(Context, AL_INVALID_ENUM, "Invalid integer property 0x%04x", param);
2231 else
2232 GetSourceiv(Source, Context, param, value);
2233 UnlockSourceList(Context);
2234
2235 ALCcontext_DecRef(Context);
2236 }
2237
2238
2239 AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3)
2240 {
2241 ALCcontext *Context;
2242 ALsource *Source;
2243
2244 Context = GetContextRef();
2245 if(!Context) return;
2246
2247 LockSourceList(Context);
2248 if((Source=LookupSource(Context, source)) == NULL)
2249 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2250 else if(!(value1 && value2 && value3))
2251 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2252 else if(!(IntValsByProp(param) == 3))
2253 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-integer property 0x%04x", param);
2254 else
2255 {
2256 ALint ivals[3];
2257 if(GetSourceiv(Source, Context, param, ivals))
2258 {
2259 *value1 = ivals[0];
2260 *value2 = ivals[1];
2261 *value3 = ivals[2];
2262 }
2263 }
2264 UnlockSourceList(Context);
2265
2266 ALCcontext_DecRef(Context);
2267 }
2268
2269
2270 AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values)
2271 {
2272 ALCcontext *Context;
2273 ALsource *Source;
2274
2275 Context = GetContextRef();
2276 if(!Context) return;
2277
2278 LockSourceList(Context);
2279 if((Source=LookupSource(Context, source)) == NULL)
2280 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2281 else if(!values)
2282 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2283 else if(!(IntValsByProp(param) > 0))
2284 alSetError(Context, AL_INVALID_ENUM, "Invalid integer-vector property 0x%04x", param);
2285 else
2286 GetSourceiv(Source, Context, param, values);
2287 UnlockSourceList(Context);
2288
2289 ALCcontext_DecRef(Context);
2290 }
2291
2292
2293 AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value)
2294 {
2295 ALCcontext *Context;
2296 ALsource *Source;
2297
2298 Context = GetContextRef();
2299 if(!Context) return;
2300
2301 LockSourceList(Context);
2302 if((Source=LookupSource(Context, source)) == NULL)
2303 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2304 else if(!value)
2305 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2306 else if(!(Int64ValsByProp(param) == 1))
2307 alSetError(Context, AL_INVALID_ENUM, "Invalid integer64 property 0x%04x", param);
2308 else
2309 GetSourcei64v(Source, Context, param, value);
2310 UnlockSourceList(Context);
2311
2312 ALCcontext_DecRef(Context);
2313 }
2314
2315 AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3)
2316 {
2317 ALCcontext *Context;
2318 ALsource *Source;
2319
2320 Context = GetContextRef();
2321 if(!Context) return;
2322
2323 LockSourceList(Context);
2324 if((Source=LookupSource(Context, source)) == NULL)
2325 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2326 else if(!(value1 && value2 && value3))
2327 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2328 else if(!(Int64ValsByProp(param) == 3))
2329 alSetError(Context, AL_INVALID_ENUM, "Invalid 3-integer64 property 0x%04x", param);
2330 else
2331 {
2332 ALint64 i64vals[3];
2333 if(GetSourcei64v(Source, Context, param, i64vals))
2334 {
2335 *value1 = i64vals[0];
2336 *value2 = i64vals[1];
2337 *value3 = i64vals[2];
2338 }
2339 }
2340 UnlockSourceList(Context);
2341
2342 ALCcontext_DecRef(Context);
2343 }
2344
2345 AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values)
2346 {
2347 ALCcontext *Context;
2348 ALsource *Source;
2349
2350 Context = GetContextRef();
2351 if(!Context) return;
2352
2353 LockSourceList(Context);
2354 if((Source=LookupSource(Context, source)) == NULL)
2355 alSetError(Context, AL_INVALID_NAME, "Invalid source ID %u", source);
2356 else if(!values)
2357 alSetError(Context, AL_INVALID_VALUE, "NULL pointer");
2358 else if(!(Int64ValsByProp(param) > 0))
2359 alSetError(Context, AL_INVALID_ENUM, "Invalid integer64-vector property 0x%04x", param);
2360 else
2361 GetSourcei64v(Source, Context, param, values);
2362 UnlockSourceList(Context);
2363
2364 ALCcontext_DecRef(Context);
2365 }
2366
2367
2368 AL_API ALvoid AL_APIENTRY alSourcePlay(ALuint source)
2369 {
2370 alSourcePlayv(1, &source);
2371 }
2372 AL_API ALvoid AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)
2373 {
2374 ALCcontext *context;
2375 ALCdevice *device;
2376 ALsource *source;
2377 ALvoice *voice;
2378 ALsizei i, j;
2379
2380 context = GetContextRef();
2381 if(!context) return;
2382
2383 LockSourceList(context);
2384 if(!(n >= 0))
2385 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Playing %d sources", n);
2386 for(i = 0;i < n;i++)
2387 {
2388 if(!LookupSource(context, sources[i]))
2389 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", sources[i]);
2390 }
2391
2392 device = context->Device;
2393 ALCdevice_Lock(device);
2394 /* If the device is disconnected, go right to stopped. */
2395 if(!ATOMIC_LOAD(&device->Connected, almemory_order_acquire))
2396 {
2397 /* TODO: Send state change event? */
2398 for(i = 0;i < n;i++)
2399 {
2400 source = LookupSource(context, sources[i]);
2401 source->OffsetType = AL_NONE;
2402 source->Offset = 0.0;
2403 source->state = AL_STOPPED;
2404 }
2405 ALCdevice_Unlock(device);
2406 goto done;
2407 }
2408
2409 while(n > context->MaxVoices-context->VoiceCount)
2410 {
2411 ALsizei newcount = context->MaxVoices << 1;
2412 if(context->MaxVoices >= newcount)
2413 {
2414 ALCdevice_Unlock(device);
2415 SETERR_GOTO(context, AL_OUT_OF_MEMORY, done,
2416 "Overflow increasing voice count %d -> %d", context->MaxVoices, newcount);
2417 }
2418 AllocateVoices(context, newcount, device->NumAuxSends);
2419 }
2420
2421 for(i = 0;i < n;i++)
2422 {
2423 ALbufferlistitem *BufferList;
2424 ALbuffer *buffer = NULL;
2425 bool start_fading = false;
2426 ALint vidx = -1;
2427 ALsizei s;
2428
2429 source = LookupSource(context, sources[i]);
2430 /* Check that there is a queue containing at least one valid, non zero
2431 * length Buffer.
2432 */
2433 BufferList = source->queue;
2434 while(BufferList)
2435 {
2436 ALsizei b;
2437 for(b = 0;b < BufferList->num_buffers;b++)
2438 {
2439 buffer = BufferList->buffers[b];
2440 if(buffer && buffer->SampleLen > 0) break;
2441 }
2442 if(buffer && buffer->SampleLen > 0) break;
2443 BufferList = ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed);
2444 }
2445
2446 /* If there's nothing to play, go right to stopped. */
2447 if(UNLIKELY(!BufferList))
2448 {
2449 /* NOTE: A source without any playable buffers should not have an
2450 * ALvoice since it shouldn't be in a playing or paused state. So
2451 * there's no need to look up its voice and clear the source.
2452 */
2453 ALenum oldstate = GetSourceState(source, NULL);
2454 source->OffsetType = AL_NONE;
2455 source->Offset = 0.0;
2456 if(oldstate != AL_STOPPED)
2457 {
2458 source->state = AL_STOPPED;
2459 SendStateChangeEvent(context, source->id, AL_STOPPED);
2460 }
2461 continue;
2462 }
2463
2464 voice = GetSourceVoice(source, context);
2465 switch(GetSourceState(source, voice))
2466 {
2467 case AL_PLAYING:
2468 assert(voice != NULL);
2469 /* A source that's already playing is restarted from the beginning. */
2470 ATOMIC_STORE(&voice->current_buffer, BufferList, almemory_order_relaxed);
2471 ATOMIC_STORE(&voice->position, 0, almemory_order_relaxed);
2472 ATOMIC_STORE(&voice->position_fraction, 0, almemory_order_release);
2473 continue;
2474
2475 case AL_PAUSED:
2476 assert(voice != NULL);
2477 /* A source that's paused simply resumes. */
2478 ATOMIC_STORE(&voice->Playing, true, almemory_order_release);
2479 source->state = AL_PLAYING;
2480 SendStateChangeEvent(context, source->id, AL_PLAYING);
2481 continue;
2482
2483 default:
2484 break;
2485 }
2486
2487 /* Make sure this source isn't already active, and if not, look for an
2488 * unused voice to put it in.
2489 */
2490 assert(voice == NULL);
2491 for(j = 0;j < context->VoiceCount;j++)
2492 {
2493 if(ATOMIC_LOAD(&context->Voices[j]->Source, almemory_order_acquire) == NULL)
2494 {
2495 vidx = j;
2496 break;
2497 }
2498 }
2499 if(vidx == -1)
2500 vidx = context->VoiceCount++;
2501 voice = context->Voices[vidx];
2502 ATOMIC_STORE(&voice->Playing, false, almemory_order_release);
2503
2504 ATOMIC_FLAG_TEST_AND_SET(&source->PropsClean, almemory_order_acquire);
2505 UpdateSourceProps(source, voice, device->NumAuxSends, context);
2506
2507 /* A source that's not playing or paused has any offset applied when it
2508 * starts playing.
2509 */
2510 if(source->Looping)
2511 ATOMIC_STORE(&voice->loop_buffer, source->queue, almemory_order_relaxed);
2512 else
2513 ATOMIC_STORE(&voice->loop_buffer, NULL, almemory_order_relaxed);
2514 ATOMIC_STORE(&voice->current_buffer, BufferList, almemory_order_relaxed);
2515 ATOMIC_STORE(&voice->position, 0, almemory_order_relaxed);
2516 ATOMIC_STORE(&voice->position_fraction, 0, almemory_order_relaxed);
2517 if(source->OffsetType != AL_NONE)
2518 {
2519 ApplyOffset(source, voice);
2520 start_fading = ATOMIC_LOAD(&voice->position, almemory_order_relaxed) != 0 ||
2521 ATOMIC_LOAD(&voice->position_fraction, almemory_order_relaxed) != 0 ||
2522 ATOMIC_LOAD(&voice->current_buffer, almemory_order_relaxed) != BufferList;
2523 }
2524
2525 voice->NumChannels = ChannelsFromFmt(buffer->FmtChannels);
2526 voice->SampleSize = BytesFromFmt(buffer->FmtType);
2527
2528 /* Clear previous samples. */
2529 memset(voice->PrevSamples, 0, sizeof(voice->PrevSamples));
2530
2531 /* Clear the stepping value so the mixer knows not to mix this until
2532 * the update gets applied.
2533 */
2534 voice->Step = 0;
2535
2536 voice->Flags = start_fading ? VOICE_IS_FADING : 0;
2537 if(source->SourceType == AL_STATIC) voice->Flags |= VOICE_IS_STATIC;
2538 memset(voice->Direct.Params, 0, sizeof(voice->Direct.Params[0])*voice->NumChannels);
2539 for(s = 0;s < device->NumAuxSends;s++)
2540 memset(voice->Send[s].Params, 0, sizeof(voice->Send[s].Params[0])*voice->NumChannels);
2541 if(device->AvgSpeakerDist > 0.0f)
2542 {
2543 ALfloat w1 = SPEEDOFSOUNDMETRESPERSEC /
2544 (device->AvgSpeakerDist * device->Frequency);
2545 for(j = 0;j < voice->NumChannels;j++)
2546 NfcFilterCreate(&voice->Direct.Params[j].NFCtrlFilter, 0.0f, w1);
2547 }
2548
2549 ATOMIC_STORE(&voice->Source, source, almemory_order_relaxed);
2550 ATOMIC_STORE(&voice->Playing, true, almemory_order_release);
2551 source->state = AL_PLAYING;
2552 source->VoiceIdx = vidx;
2553
2554 SendStateChangeEvent(context, source->id, AL_PLAYING);
2555 }
2556 ALCdevice_Unlock(device);
2557
2558 done:
2559 UnlockSourceList(context);
2560 ALCcontext_DecRef(context);
2561 }
2562
2563 AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)
2564 {
2565 alSourcePausev(1, &source);
2566 }
2567 AL_API ALvoid AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
2568 {
2569 ALCcontext *context;
2570 ALCdevice *device;
2571 ALsource *source;
2572 ALvoice *voice;
2573 ALsizei i;
2574
2575 context = GetContextRef();
2576 if(!context) return;
2577
2578 LockSourceList(context);
2579 if(!(n >= 0))
2580 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Pausing %d sources", n);
2581 for(i = 0;i < n;i++)
2582 {
2583 if(!LookupSource(context, sources[i]))
2584 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", sources[i]);
2585 }
2586
2587 device = context->Device;
2588 ALCdevice_Lock(device);
2589 for(i = 0;i < n;i++)
2590 {
2591 source = LookupSource(context, sources[i]);
2592 if((voice=GetSourceVoice(source, context)) != NULL)
2593 ATOMIC_STORE(&voice->Playing, false, almemory_order_release);
2594 if(GetSourceState(source, voice) == AL_PLAYING)
2595 {
2596 source->state = AL_PAUSED;
2597 SendStateChangeEvent(context, source->id, AL_PAUSED);
2598 }
2599 }
2600 ALCdevice_Unlock(device);
2601
2602 done:
2603 UnlockSourceList(context);
2604 ALCcontext_DecRef(context);
2605 }
2606
2607 AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)
2608 {
2609 alSourceStopv(1, &source);
2610 }
2611 AL_API ALvoid AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
2612 {
2613 ALCcontext *context;
2614 ALCdevice *device;
2615 ALsource *source;
2616 ALvoice *voice;
2617 ALsizei i;
2618
2619 context = GetContextRef();
2620 if(!context) return;
2621
2622 LockSourceList(context);
2623 if(!(n >= 0))
2624 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Stopping %d sources", n);
2625 for(i = 0;i < n;i++)
2626 {
2627 if(!LookupSource(context, sources[i]))
2628 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", sources[i]);
2629 }
2630
2631 device = context->Device;
2632 ALCdevice_Lock(device);
2633 for(i = 0;i < n;i++)
2634 {
2635 ALenum oldstate;
2636 source = LookupSource(context, sources[i]);
2637 if((voice=GetSourceVoice(source, context)) != NULL)
2638 {
2639 ATOMIC_STORE(&voice->Source, NULL, almemory_order_relaxed);
2640 ATOMIC_STORE(&voice->Playing, false, almemory_order_release);
2641 voice = NULL;
2642 }
2643 oldstate = GetSourceState(source, voice);
2644 if(oldstate != AL_INITIAL && oldstate != AL_STOPPED)
2645 {
2646 source->state = AL_STOPPED;
2647 SendStateChangeEvent(context, source->id, AL_STOPPED);
2648 }
2649 source->OffsetType = AL_NONE;
2650 source->Offset = 0.0;
2651 }
2652 ALCdevice_Unlock(device);
2653
2654 done:
2655 UnlockSourceList(context);
2656 ALCcontext_DecRef(context);
2657 }
2658
2659 AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)
2660 {
2661 alSourceRewindv(1, &source);
2662 }
2663 AL_API ALvoid AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
2664 {
2665 ALCcontext *context;
2666 ALCdevice *device;
2667 ALsource *source;
2668 ALvoice *voice;
2669 ALsizei i;
2670
2671 context = GetContextRef();
2672 if(!context) return;
2673
2674 LockSourceList(context);
2675 if(!(n >= 0))
2676 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Rewinding %d sources", n);
2677 for(i = 0;i < n;i++)
2678 {
2679 if(!LookupSource(context, sources[i]))
2680 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", sources[i]);
2681 }
2682
2683 device = context->Device;
2684 ALCdevice_Lock(device);
2685 for(i = 0;i < n;i++)
2686 {
2687 source = LookupSource(context, sources[i]);
2688 if((voice=GetSourceVoice(source, context)) != NULL)
2689 {
2690 ATOMIC_STORE(&voice->Source, NULL, almemory_order_relaxed);
2691 ATOMIC_STORE(&voice->Playing, false, almemory_order_release);
2692 voice = NULL;
2693 }
2694 if(GetSourceState(source, voice) != AL_INITIAL)
2695 {
2696 source->state = AL_INITIAL;
2697 SendStateChangeEvent(context, source->id, AL_INITIAL);
2698 }
2699 source->OffsetType = AL_NONE;
2700 source->Offset = 0.0;
2701 }
2702 ALCdevice_Unlock(device);
2703
2704 done:
2705 UnlockSourceList(context);
2706 ALCcontext_DecRef(context);
2707 }
2708
2709
2710 AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALuint *buffers)
2711 {
2712 ALCdevice *device;
2713 ALCcontext *context;
2714 ALsource *source;
2715 ALsizei i;
2716 ALbufferlistitem *BufferListStart;
2717 ALbufferlistitem *BufferList;
2718 ALbuffer *BufferFmt = NULL;
2719
2720 if(nb == 0)
2721 return;
2722
2723 context = GetContextRef();
2724 if(!context) return;
2725
2726 device = context->Device;
2727
2728 LockSourceList(context);
2729 if(!(nb >= 0))
2730 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Queueing %d buffers", nb);
2731 if((source=LookupSource(context, src)) == NULL)
2732 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", src);
2733
2734 if(source->SourceType == AL_STATIC)
2735 {
2736 /* Can't queue on a Static Source */
2737 SETERR_GOTO(context, AL_INVALID_OPERATION, done, "Queueing onto static source %u", src);
2738 }
2739
2740 /* Check for a valid Buffer, for its frequency and format */
2741 BufferList = source->queue;
2742 while(BufferList)
2743 {
2744 for(i = 0;i < BufferList->num_buffers;i++)
2745 {
2746 if((BufferFmt=BufferList->buffers[i]) != NULL)
2747 break;
2748 }
2749 if(BufferFmt) break;
2750 BufferList = ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed);
2751 }
2752
2753 LockBufferList(device);
2754 BufferListStart = NULL;
2755 BufferList = NULL;
2756 for(i = 0;i < nb;i++)
2757 {
2758 ALbuffer *buffer = NULL;
2759 if(buffers[i] && (buffer=LookupBuffer(device, buffers[i])) == NULL)
2760 SETERR_GOTO(context, AL_INVALID_NAME, buffer_error, "Queueing invalid buffer ID %u",
2761 buffers[i]);
2762
2763 if(!BufferListStart)
2764 {
2765 BufferListStart = al_calloc(DEF_ALIGN,
2766 FAM_SIZE(ALbufferlistitem, buffers, 1));
2767 BufferList = BufferListStart;
2768 }
2769 else
2770 {
2771 ALbufferlistitem *item = al_calloc(DEF_ALIGN,
2772 FAM_SIZE(ALbufferlistitem, buffers, 1));
2773 ATOMIC_STORE(&BufferList->next, item, almemory_order_relaxed);
2774 BufferList = item;
2775 }
2776 ATOMIC_INIT(&BufferList->next, NULL);
2777 BufferList->num_buffers = 1;
2778 BufferList->buffers[0] = buffer;
2779 if(!buffer) continue;
2780
2781 IncrementRef(&buffer->ref);
2782
2783 if(buffer->MappedAccess != 0 && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
2784 SETERR_GOTO(context, AL_INVALID_OPERATION, buffer_error,
2785 "Queueing non-persistently mapped buffer %u", buffer->id);
2786
2787 if(BufferFmt == NULL)
2788 BufferFmt = buffer;
2789 else if(BufferFmt->Frequency != buffer->Frequency ||
2790 BufferFmt->FmtChannels != buffer->FmtChannels ||
2791 BufferFmt->OriginalType != buffer->OriginalType)
2792 {
2793 alSetError(context, AL_INVALID_OPERATION, "Queueing buffer with mismatched format");
2794
2795 buffer_error:
2796 /* A buffer failed (invalid ID or format), so unlock and release
2797 * each buffer we had. */
2798 while(BufferListStart)
2799 {
2800 ALbufferlistitem *next = ATOMIC_LOAD(&BufferListStart->next,
2801 almemory_order_relaxed);
2802 for(i = 0;i < BufferListStart->num_buffers;i++)
2803 {
2804 if((buffer=BufferListStart->buffers[i]) != NULL)
2805 DecrementRef(&buffer->ref);
2806 }
2807 al_free(BufferListStart);
2808 BufferListStart = next;
2809 }
2810 UnlockBufferList(device);
2811 goto done;
2812 }
2813 }
2814 /* All buffers good. */
2815 UnlockBufferList(device);
2816
2817 /* Source is now streaming */
2818 source->SourceType = AL_STREAMING;
2819
2820 if(!(BufferList=source->queue))
2821 source->queue = BufferListStart;
2822 else
2823 {
2824 ALbufferlistitem *next;
2825 while((next=ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed)) != NULL)
2826 BufferList = next;
2827 ATOMIC_STORE(&BufferList->next, BufferListStart, almemory_order_release);
2828 }
2829
2830 done:
2831 UnlockSourceList(context);
2832 ALCcontext_DecRef(context);
2833 }
2834
2835 AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint *buffers)
2836 {
2837 ALCcontext *context;
2838 ALsource *source;
2839 ALbufferlistitem *BufferList;
2840 ALbufferlistitem *Current;
2841 ALvoice *voice;
2842 ALsizei i;
2843
2844 context = GetContextRef();
2845 if(!context) return;
2846
2847 LockSourceList(context);
2848 if(!(nb >= 0))
2849 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Unqueueing %d buffers", nb);
2850 if((source=LookupSource(context, src)) == NULL)
2851 SETERR_GOTO(context, AL_INVALID_NAME, done, "Invalid source ID %u", src);
2852
2853 /* Nothing to unqueue. */
2854 if(nb == 0) goto done;
2855
2856 if(source->Looping)
2857 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Unqueueing from looping source %u", src);
2858 if(source->SourceType != AL_STREAMING)
2859 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Unqueueing from a non-streaming source %u",
2860 src);
2861
2862 /* Make sure enough buffers have been processed to unqueue. */
2863 BufferList = source->queue;
2864 Current = NULL;
2865 if((voice=GetSourceVoice(source, context)) != NULL)
2866 Current = ATOMIC_LOAD(&voice->current_buffer, almemory_order_relaxed);
2867 else if(source->state == AL_INITIAL)
2868 Current = BufferList;
2869 if(BufferList == Current)
2870 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Unqueueing pending buffers");
2871
2872 i = BufferList->num_buffers;
2873 while(i < nb)
2874 {
2875 /* If the next bufferlist to check is NULL or is the current one, it's
2876 * trying to unqueue pending buffers.
2877 */
2878 ALbufferlistitem *next = ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed);
2879 if(!next || next == Current)
2880 SETERR_GOTO(context, AL_INVALID_VALUE, done, "Unqueueing pending buffers");
2881 BufferList = next;
2882
2883 i += BufferList->num_buffers;
2884 }
2885
2886 while(nb > 0)
2887 {
2888 ALbufferlistitem *head = source->queue;
2889 ALbufferlistitem *next = ATOMIC_LOAD(&head->next, almemory_order_relaxed);
2890 for(i = 0;i < head->num_buffers && nb > 0;i++,nb--)
2891 {
2892 ALbuffer *buffer = head->buffers[i];
2893 if(!buffer)
2894 *(buffers++) = 0;
2895 else
2896 {
2897 *(buffers++) = buffer->id;
2898 DecrementRef(&buffer->ref);
2899 }
2900 }
2901 if(i < head->num_buffers)
2902 {
2903 /* This head has some buffers left over, so move them to the front
2904 * and update the count.
2905 */
2906 ALsizei j = 0;
2907 while(i < head->num_buffers)
2908 head->buffers[j++] = head->buffers[i++];
2909 head->num_buffers = j;
2910 break;
2911 }
2912
2913 /* Otherwise, free this item and set the source queue head to the next
2914 * one.
2915 */
2916 al_free(head);
2917 source->queue = next;
2918 }
2919
2920 done:
2921 UnlockSourceList(context);
2922 ALCcontext_DecRef(context);
2923 }
2924
2925
2926 static void InitSourceParams(ALsource *Source, ALsizei num_sends)
2927 {
2928 ALsizei i;
2929
2930 Source->InnerAngle = 360.0f;
2931 Source->OuterAngle = 360.0f;
2932 Source->Pitch = 1.0f;
2933 Source->Position[0] = 0.0f;
2934 Source->Position[1] = 0.0f;
2935 Source->Position[2] = 0.0f;
2936 Source->Velocity[0] = 0.0f;
2937 Source->Velocity[1] = 0.0f;
2938 Source->Velocity[2] = 0.0f;
2939 Source->Direction[0] = 0.0f;
2940 Source->Direction[1] = 0.0f;
2941 Source->Direction[2] = 0.0f;
2942 Source->Orientation[0][0] = 0.0f;
2943 Source->Orientation[0][1] = 0.0f;
2944 Source->Orientation[0][2] = -1.0f;
2945 Source->Orientation[1][0] = 0.0f;
2946 Source->Orientation[1][1] = 1.0f;
2947 Source->Orientation[1][2] = 0.0f;
2948 Source->RefDistance = 1.0f;
2949 Source->MaxDistance = FLT_MAX;
2950 Source->RolloffFactor = 1.0f;
2951 Source->Gain = 1.0f;
2952 Source->MinGain = 0.0f;
2953 Source->MaxGain = 1.0f;
2954 Source->OuterGain = 0.0f;
2955 Source->OuterGainHF = 1.0f;
2956
2957 Source->DryGainHFAuto = AL_TRUE;
2958 Source->WetGainAuto = AL_TRUE;
2959 Source->WetGainHFAuto = AL_TRUE;
2960 Source->AirAbsorptionFactor = 0.0f;
2961 Source->RoomRolloffFactor = 0.0f;
2962 Source->DopplerFactor = 1.0f;
2963 Source->HeadRelative = AL_FALSE;
2964 Source->Looping = AL_FALSE;
2965 Source->DistanceModel = DefaultDistanceModel;
2966 Source->Resampler = ResamplerDefault;
2967 Source->DirectChannels = AL_FALSE;
2968 Source->Spatialize = SpatializeAuto;
2969
2970 Source->StereoPan[0] = DEG2RAD( 30.0f);
2971 Source->StereoPan[1] = DEG2RAD(-30.0f);
2972
2973 Source->Radius = 0.0f;
2974
2975 Source->Direct.Gain = 1.0f;
2976 Source->Direct.GainHF = 1.0f;
2977 Source->Direct.HFReference = LOWPASSFREQREF;
2978 Source->Direct.GainLF = 1.0f;
2979 Source->Direct.LFReference = HIGHPASSFREQREF;
2980 Source->Send = al_calloc(16, num_sends*sizeof(Source->Send[0]));
2981 for(i = 0;i < num_sends;i++)
2982 {
2983 Source->Send[i].Slot = NULL;
2984 Source->Send[i].Gain = 1.0f;
2985 Source->Send[i].GainHF = 1.0f;
2986 Source->Send[i].HFReference = LOWPASSFREQREF;
2987 Source->Send[i].GainLF = 1.0f;
2988 Source->Send[i].LFReference = HIGHPASSFREQREF;
2989 }
2990
2991 Source->Offset = 0.0;
2992 Source->OffsetType = AL_NONE;
2993 Source->SourceType = AL_UNDETERMINED;
2994 Source->state = AL_INITIAL;
2995
2996 Source->queue = NULL;
2997
2998 /* No way to do an 'init' here, so just test+set with relaxed ordering and
2999 * ignore the test.
3000 */
3001 ATOMIC_FLAG_TEST_AND_SET(&Source->PropsClean, almemory_order_relaxed);
3002
3003 Source->VoiceIdx = -1;
3004 }
3005
3006 static void DeinitSource(ALsource *source, ALsizei num_sends)
3007 {
3008 ALbufferlistitem *BufferList;
3009 ALsizei i;
3010
3011 BufferList = source->queue;
3012 while(BufferList != NULL)
3013 {
3014 ALbufferlistitem *next = ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed);
3015 for(i = 0;i < BufferList->num_buffers;i++)
3016 {
3017 if(BufferList->buffers[i] != NULL)
3018 DecrementRef(&BufferList->buffers[i]->ref);
3019 }
3020 al_free(BufferList);
3021 BufferList = next;
3022 }
3023 source->queue = NULL;
3024
3025 if(source->Send)
3026 {
3027 for(i = 0;i < num_sends;i++)
3028 {
3029 if(source->Send[i].Slot)
3030 DecrementRef(&source->Send[i].Slot->ref);
3031 source->Send[i].Slot = NULL;
3032 }
3033 al_free(source->Send);
3034 source->Send = NULL;
3035 }
3036 }
3037
3038 static void UpdateSourceProps(ALsource *source, ALvoice *voice, ALsizei num_sends, ALCcontext *context)
3039 {
3040 struct ALvoiceProps *props;
3041 ALsizei i;
3042
3043 /* Get an unused property container, or allocate a new one as needed. */
3044 props = ATOMIC_LOAD(&context->FreeVoiceProps, almemory_order_acquire);
3045 if(!props)
3046 props = al_calloc(16, FAM_SIZE(struct ALvoiceProps, Send, num_sends));
3047 else
3048 {
3049 struct ALvoiceProps *next;
3050 do {
3051 next = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
3052 } while(ATOMIC_COMPARE_EXCHANGE_PTR_WEAK(&context->FreeVoiceProps, &props, next,
3053 almemory_order_acq_rel, almemory_order_acquire) == 0);
3054 }
3055
3056 /* Copy in current property values. */
3057 props->Pitch = source->Pitch;
3058 props->Gain = source->Gain;
3059 props->OuterGain = source->OuterGain;
3060 props->MinGain = source->MinGain;
3061 props->MaxGain = source->MaxGain;
3062 props->InnerAngle = source->InnerAngle;
3063 props->OuterAngle = source->OuterAngle;
3064 props->RefDistance = source->RefDistance;
3065 props->MaxDistance = source->MaxDistance;
3066 props->RolloffFactor = source->RolloffFactor;
3067 for(i = 0;i < 3;i++)
3068 props->Position[i] = source->Position[i];
3069 for(i = 0;i < 3;i++)
3070 props->Velocity[i] = source->Velocity[i];
3071 for(i = 0;i < 3;i++)
3072 props->Direction[i] = source->Direction[i];
3073 for(i = 0;i < 2;i++)
3074 {
3075 ALsizei j;
3076 for(j = 0;j < 3;j++)
3077 props->Orientation[i][j] = source->Orientation[i][j];
3078 }
3079 props->HeadRelative = source->HeadRelative;
3080 props->DistanceModel = source->DistanceModel;
3081 props->Resampler = source->Resampler;
3082 props->DirectChannels = source->DirectChannels;
3083 props->SpatializeMode = source->Spatialize;
3084
3085 props->DryGainHFAuto = source->DryGainHFAuto;
3086 props->WetGainAuto = source->WetGainAuto;
3087 props->WetGainHFAuto = source->WetGainHFAuto;
3088 props->OuterGainHF = source->OuterGainHF;
3089
3090 props->AirAbsorptionFactor = source->AirAbsorptionFactor;
3091 props->RoomRolloffFactor = source->RoomRolloffFactor;
3092 props->DopplerFactor = source->DopplerFactor;
3093
3094 props->StereoPan[0] = source->StereoPan[0];
3095 props->StereoPan[1] = source->StereoPan[1];
3096
3097 props->Radius = source->Radius;
3098
3099 props->Direct.Gain = source->Direct.Gain;
3100 props->Direct.GainHF = source->Direct.GainHF;
3101 props->Direct.HFReference = source->Direct.HFReference;
3102 props->Direct.GainLF = source->Direct.GainLF;
3103 props->Direct.LFReference = source->Direct.LFReference;
3104
3105 for(i = 0;i < num_sends;i++)
3106 {
3107 props->Send[i].Slot = source->Send[i].Slot;
3108 props->Send[i].Gain = source->Send[i].Gain;
3109 props->Send[i].GainHF = source->Send[i].GainHF;
3110 props->Send[i].HFReference = source->Send[i].HFReference;
3111 props->Send[i].GainLF = source->Send[i].GainLF;
3112 props->Send[i].LFReference = source->Send[i].LFReference;
3113 }
3114
3115 /* Set the new container for updating internal parameters. */
3116 props = ATOMIC_EXCHANGE_PTR(&voice->Update, props, almemory_order_acq_rel);
3117 if(props)
3118 {
3119 /* If there was an unused update container, put it back in the
3120 * freelist.
3121 */
3122 ATOMIC_REPLACE_HEAD(struct ALvoiceProps*, &context->FreeVoiceProps, props);
3123 }
3124 }
3125
3126 void UpdateAllSourceProps(ALCcontext *context)
3127 {
3128 ALsizei num_sends = context->Device->NumAuxSends;
3129 ALsizei pos;
3130
3131 for(pos = 0;pos < context->VoiceCount;pos++)
3132 {
3133 ALvoice *voice = context->Voices[pos];
3134 ALsource *source = ATOMIC_LOAD(&voice->Source, almemory_order_acquire);
3135 if(source && !ATOMIC_FLAG_TEST_AND_SET(&source->PropsClean, almemory_order_acq_rel))
3136 UpdateSourceProps(source, voice, num_sends, context);
3137 }
3138 }
3139
3140
3141 /* GetSourceSampleOffset
3142 *
3143 * Gets the current read offset for the given Source, in 32.32 fixed-point
3144 * samples. The offset is relative to the start of the queue (not the start of
3145 * the current buffer).
3146 */
3147 static ALint64 GetSourceSampleOffset(ALsource *Source, ALCcontext *context, ALuint64 *clocktime)
3148 {
3149 ALCdevice *device = context->Device;
3150 const ALbufferlistitem *Current;
3151 ALuint64 readPos;
3152 ALuint refcount;
3153 ALvoice *voice;
3154
3155 do {
3156 Current = NULL;
3157 readPos = 0;
3158 while(((refcount=ATOMIC_LOAD(&device->MixCount, almemory_order_acquire))&1))
3159 althrd_yield();
3160 *clocktime = GetDeviceClockTime(device);
3161
3162 voice = GetSourceVoice(Source, context);
3163 if(voice)
3164 {
3165 Current = ATOMIC_LOAD(&voice->current_buffer, almemory_order_relaxed);
3166
3167 readPos = (ALuint64)ATOMIC_LOAD(&voice->position, almemory_order_relaxed) << 32;
3168 readPos |= (ALuint64)ATOMIC_LOAD(&voice->position_fraction, almemory_order_relaxed) <<
3169 (32-FRACTIONBITS);
3170 }
3171 ATOMIC_THREAD_FENCE(almemory_order_acquire);
3172 } while(refcount != ATOMIC_LOAD(&device->MixCount, almemory_order_relaxed));
3173
3174 if(voice)
3175 {
3176 const ALbufferlistitem *BufferList = Source->queue;
3177 while(BufferList && BufferList != Current)
3178 {
3179 ALsizei max_len = 0;
3180 ALsizei i;
3181
3182 for(i = 0;i < BufferList->num_buffers;i++)
3183 {
3184 ALbuffer *buffer = BufferList->buffers[i];
3185 if(buffer) max_len = maxi(max_len, buffer->SampleLen);
3186 }
3187 readPos += (ALuint64)max_len << 32;
3188 BufferList = ATOMIC_LOAD(&CONST_CAST(ALbufferlistitem*,BufferList)->next,
3189 almemory_order_relaxed);
3190 }
3191 readPos = minu64(readPos, U64(0x7fffffffffffffff));
3192 }
3193
3194 return (ALint64)readPos;
3195 }
3196
3197 /* GetSourceSecOffset
3198 *
3199 * Gets the current read offset for the given Source, in seconds. The offset is
3200 * relative to the start of the queue (not the start of the current buffer).
3201 */
3202 static ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, ALuint64 *clocktime)
3203 {
3204 ALCdevice *device = context->Device;
3205 const ALbufferlistitem *Current;
3206 ALuint64 readPos;
3207 ALuint refcount;
3208 ALdouble offset;
3209 ALvoice *voice;
3210
3211 do {
3212 Current = NULL;
3213 readPos = 0;
3214 while(((refcount=ATOMIC_LOAD(&device->MixCount, almemory_order_acquire))&1))
3215 althrd_yield();
3216 *clocktime = GetDeviceClockTime(device);
3217
3218 voice = GetSourceVoice(Source, context);
3219 if(voice)
3220 {
3221 Current = ATOMIC_LOAD(&voice->current_buffer, almemory_order_relaxed);
3222
3223 readPos = (ALuint64)ATOMIC_LOAD(&voice->position, almemory_order_relaxed) <<
3224 FRACTIONBITS;
3225 readPos |= ATOMIC_LOAD(&voice->position_fraction, almemory_order_relaxed);
3226 }
3227 ATOMIC_THREAD_FENCE(almemory_order_acquire);
3228 } while(refcount != ATOMIC_LOAD(&device->MixCount, almemory_order_relaxed));
3229
3230 offset = 0.0;
3231 if(voice)
3232 {
3233 const ALbufferlistitem *BufferList = Source->queue;
3234 const ALbuffer *BufferFmt = NULL;
3235 while(BufferList && BufferList != Current)
3236 {
3237 ALsizei max_len = 0;
3238 ALsizei i;
3239
3240 for(i = 0;i < BufferList->num_buffers;i++)
3241 {
3242 ALbuffer *buffer = BufferList->buffers[i];
3243 if(buffer)
3244 {
3245 if(!BufferFmt) BufferFmt = buffer;
3246 max_len = maxi(max_len, buffer->SampleLen);
3247 }
3248 }
3249 readPos += (ALuint64)max_len << FRACTIONBITS;
3250 BufferList = ATOMIC_LOAD(&CONST_CAST(ALbufferlistitem*,BufferList)->next,
3251 almemory_order_relaxed);
3252 }
3253
3254 while(BufferList && !BufferFmt)
3255 {
3256 ALsizei i;
3257 for(i = 0;i < BufferList->num_buffers && !BufferFmt;i++)
3258 BufferFmt = BufferList->buffers[i];
3259 BufferList = ATOMIC_LOAD(&CONST_CAST(ALbufferlistitem*,BufferList)->next,
3260 almemory_order_relaxed);
3261 }
3262 assert(BufferFmt != NULL);
3263
3264 offset = (ALdouble)readPos / (ALdouble)FRACTIONONE /
3265 (ALdouble)BufferFmt->Frequency;
3266 }
3267
3268 return offset;
3269 }
3270
3271 /* GetSourceOffset
3272 *
3273 * Gets the current read offset for the given Source, in the appropriate format
3274 * (Bytes, Samples or Seconds). The offset is relative to the start of the
3275 * queue (not the start of the current buffer).
3276 */
3277 static ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
3278 {
3279 ALCdevice *device = context->Device;
3280 const ALbufferlistitem *Current;
3281 ALuint readPos;
3282 ALsizei readPosFrac;
3283 ALuint refcount;
3284 ALdouble offset;
3285 ALvoice *voice;
3286
3287 do {
3288 Current = NULL;
3289 readPos = readPosFrac = 0;
3290 while(((refcount=ATOMIC_LOAD(&device->MixCount, almemory_order_acquire))&1))
3291 althrd_yield();
3292 voice = GetSourceVoice(Source, context);
3293 if(voice)
3294 {
3295 Current = ATOMIC_LOAD(&voice->current_buffer, almemory_order_relaxed);
3296
3297 readPos = ATOMIC_LOAD(&voice->position, almemory_order_relaxed);
3298 readPosFrac = ATOMIC_LOAD(&voice->position_fraction, almemory_order_relaxed);
3299 }
3300 ATOMIC_THREAD_FENCE(almemory_order_acquire);
3301 } while(refcount != ATOMIC_LOAD(&device->MixCount, almemory_order_relaxed));
3302
3303 offset = 0.0;
3304 if(voice)
3305 {
3306 const ALbufferlistitem *BufferList = Source->queue;
3307 const ALbuffer *BufferFmt = NULL;
3308 ALboolean readFin = AL_FALSE;
3309 ALuint totalBufferLen = 0;
3310
3311 while(BufferList != NULL)
3312 {
3313 ALsizei max_len = 0;
3314 ALsizei i;
3315
3316 readFin = readFin || (BufferList == Current);
3317 for(i = 0;i < BufferList->num_buffers;i++)
3318 {
3319 ALbuffer *buffer = BufferList->buffers[i];
3320 if(buffer)
3321 {
3322 if(!BufferFmt) BufferFmt = buffer;
3323 max_len = maxi(max_len, buffer->SampleLen);
3324 }
3325 }
3326 totalBufferLen += max_len;
3327 if(!readFin) readPos += max_len;
3328
3329 BufferList = ATOMIC_LOAD(&CONST_CAST(ALbufferlistitem*,BufferList)->next,
3330 almemory_order_relaxed);
3331 }
3332 assert(BufferFmt != NULL);
3333
3334 if(Source->Looping)
3335 readPos %= totalBufferLen;
3336 else
3337 {
3338 /* Wrap back to 0 */
3339 if(readPos >= totalBufferLen)
3340 readPos = readPosFrac = 0;
3341 }
3342
3343 offset = 0.0;
3344 switch(name)
3345 {
3346 case AL_SEC_OFFSET:
3347 offset = (readPos + (ALdouble)readPosFrac/FRACTIONONE) / BufferFmt->Frequency;
3348 break;
3349
3350 case AL_SAMPLE_OFFSET:
3351 offset = readPos + (ALdouble)readPosFrac/FRACTIONONE;
3352 break;
3353
3354 case AL_BYTE_OFFSET:
3355 if(BufferFmt->OriginalType == UserFmtIMA4)
3356 {
3357 ALsizei align = (BufferFmt->OriginalAlign-1)/2 + 4;
3358 ALuint BlockSize = align * ChannelsFromFmt(BufferFmt->FmtChannels);
3359 ALuint FrameBlockSize = BufferFmt->OriginalAlign;
3360
3361 /* Round down to nearest ADPCM block */
3362 offset = (ALdouble)(readPos / FrameBlockSize * BlockSize);
3363 }
3364 else if(BufferFmt->OriginalType == UserFmtMSADPCM)
3365 {
3366 ALsizei align = (BufferFmt->OriginalAlign-2)/2 + 7;
3367 ALuint BlockSize = align * ChannelsFromFmt(BufferFmt->FmtChannels);
3368 ALuint FrameBlockSize = BufferFmt->OriginalAlign;
3369
3370 /* Round down to nearest ADPCM block */
3371 offset = (ALdouble)(readPos / FrameBlockSize * BlockSize);
3372 }
3373 else
3374 {
3375 ALuint FrameSize = FrameSizeFromFmt(BufferFmt->FmtChannels,
3376 BufferFmt->FmtType);
3377 offset = (ALdouble)(readPos * FrameSize);
3378 }
3379 break;
3380 }
3381 }
3382
3383 return offset;
3384 }
3385
3386
3387 /* ApplyOffset
3388 *
3389 * Apply the stored playback offset to the Source. This function will update
3390 * the number of buffers "played" given the stored offset.
3391 */
3392 static ALboolean ApplyOffset(ALsource *Source, ALvoice *voice)
3393 {
3394 ALbufferlistitem *BufferList;
3395 ALuint bufferLen, totalBufferLen;
3396 ALuint offset = 0;
3397 ALsizei frac = 0;
3398
3399 /* Get sample frame offset */
3400 if(!GetSampleOffset(Source, &offset, &frac))
3401 return AL_FALSE;
3402
3403 totalBufferLen = 0;
3404 BufferList = Source->queue;
3405 while(BufferList && totalBufferLen <= offset)
3406 {
3407 ALsizei max_len = 0;
3408 ALsizei i;
3409
3410 for(i = 0;i < BufferList->num_buffers;i++)
3411 {
3412 ALbuffer *buffer = BufferList->buffers[i];
3413 if(buffer) max_len = maxi(max_len, buffer->SampleLen);
3414 }
3415 bufferLen = max_len;
3416
3417 if(bufferLen > offset-totalBufferLen)
3418 {
3419 /* Offset is in this buffer */
3420 ATOMIC_STORE(&voice->position, offset - totalBufferLen, almemory_order_relaxed);
3421 ATOMIC_STORE(&voice->position_fraction, frac, almemory_order_relaxed);
3422 ATOMIC_STORE(&voice->current_buffer, BufferList, almemory_order_release);
3423 return AL_TRUE;
3424 }
3425
3426 totalBufferLen += bufferLen;
3427
3428 BufferList = ATOMIC_LOAD(&BufferList->next, almemory_order_relaxed);
3429 }
3430
3431 /* Offset is out of range of the queue */
3432 return AL_FALSE;
3433 }
3434
3435
3436 /* GetSampleOffset
3437 *
3438 * Retrieves the sample offset into the Source's queue (from the Sample, Byte
3439 * or Second offset supplied by the application). This takes into account the
3440 * fact that the buffer format may have been modifed since.
3441 */
3442 static ALboolean GetSampleOffset(ALsource *Source, ALuint *offset, ALsizei *frac)
3443 {
3444 const ALbuffer *BufferFmt = NULL;
3445 const ALbufferlistitem *BufferList;
3446 ALdouble dbloff, dblfrac;
3447
3448 /* Find the first valid Buffer in the Queue */
3449 BufferList = Source->queue;
3450 while(BufferList)
3451 {
3452 ALsizei i;
3453 for(i = 0;i < BufferList->num_buffers && !BufferFmt;i++)
3454 BufferFmt = BufferList->buffers[i];
3455 if(BufferFmt) break;
3456 BufferList = ATOMIC_LOAD(&CONST_CAST(ALbufferlistitem*,BufferList)->next,
3457 almemory_order_relaxed);
3458 }
3459 if(!BufferFmt)
3460 {
3461 Source->OffsetType = AL_NONE;
3462 Source->Offset = 0.0;
3463 return AL_FALSE;
3464 }
3465
3466 switch(Source->OffsetType)
3467 {
3468 case AL_BYTE_OFFSET:
3469 /* Determine the ByteOffset (and ensure it is block aligned) */
3470 *offset = (ALuint)Source->Offset;
3471 if(BufferFmt->OriginalType == UserFmtIMA4)
3472 {
3473 ALsizei align = (BufferFmt->OriginalAlign-1)/2 + 4;
3474 *offset /= align * ChannelsFromFmt(BufferFmt->FmtChannels);
3475 *offset *= BufferFmt->OriginalAlign;
3476 }
3477 else if(BufferFmt->OriginalType == UserFmtMSADPCM)
3478 {
3479 ALsizei align = (BufferFmt->OriginalAlign-2)/2 + 7;
3480 *offset /= align * ChannelsFromFmt(BufferFmt->FmtChannels);
3481 *offset *= BufferFmt->OriginalAlign;
3482 }
3483 else
3484 *offset /= FrameSizeFromFmt(BufferFmt->FmtChannels, BufferFmt->FmtType);
3485 *frac = 0;
3486 break;
3487
3488 case AL_SAMPLE_OFFSET:
3489 dblfrac = modf(Source->Offset, &dbloff);
3490 *offset = (ALuint)mind(dbloff, UINT_MAX);
3491 *frac = (ALsizei)mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0);
3492 break;
3493
3494 case AL_SEC_OFFSET:
3495 dblfrac = modf(Source->Offset*BufferFmt->Frequency, &dbloff);
3496 *offset = (ALuint)mind(dbloff, UINT_MAX);
3497 *frac = (ALsizei)mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0);
3498 break;
3499 }
3500 Source->OffsetType = AL_NONE;
3501 Source->Offset = 0.0;
3502
3503 return AL_TRUE;
3504 }
3505
3506
3507 static ALsource *AllocSource(ALCcontext *context)
3508 {
3509 ALCdevice *device = context->Device;
3510 SourceSubList *sublist, *subend;
3511 ALsource *source = NULL;
3512 ALsizei lidx = 0;
3513 ALsizei slidx;
3514
3515 almtx_lock(&context->SourceLock);
3516 if(context->NumSources >= device->SourcesMax)
3517 {
3518 almtx_unlock(&context->SourceLock);
3519 alSetError(context, AL_OUT_OF_MEMORY, "Exceeding %u source limit", device->SourcesMax);
3520 return NULL;
3521 }
3522 sublist = VECTOR_BEGIN(context->SourceList);
3523 subend = VECTOR_END(context->SourceList);
3524 for(;sublist != subend;++sublist)
3525 {
3526 if(sublist->FreeMask)
3527 {
3528 slidx = CTZ64(sublist->FreeMask);
3529 source = sublist->Sources + slidx;
3530 break;
3531 }
3532 ++lidx;
3533 }
3534 if(UNLIKELY(!source))
3535 {
3536 const SourceSubList empty_sublist = { 0, NULL };
3537 /* Don't allocate so many list entries that the 32-bit ID could
3538 * overflow...
3539 */
3540 if(UNLIKELY(VECTOR_SIZE(context->SourceList) >= 1<<25))
3541 {
3542 almtx_unlock(&device->BufferLock);
3543 alSetError(context, AL_OUT_OF_MEMORY, "Too many sources allocated");
3544 return NULL;
3545 }
3546 lidx = (ALsizei)VECTOR_SIZE(context->SourceList);
3547 VECTOR_PUSH_BACK(context->SourceList, empty_sublist);
3548 sublist = &VECTOR_BACK(context->SourceList);
3549 sublist->FreeMask = ~U64(0);
3550 sublist->Sources = al_calloc(16, sizeof(ALsource)*64);
3551 if(UNLIKELY(!sublist->Sources))
3552 {
3553 VECTOR_POP_BACK(context->SourceList);
3554 almtx_unlock(&context->SourceLock);
3555 alSetError(context, AL_OUT_OF_MEMORY, "Failed to allocate source batch");
3556 return NULL;
3557 }
3558
3559 slidx = 0;
3560 source = sublist->Sources + slidx;
3561 }
3562
3563 memset(source, 0, sizeof(*source));
3564 InitSourceParams(source, device->NumAuxSends);
3565
3566 /* Add 1 to avoid source ID 0. */
3567 source->id = ((lidx<<6) | slidx) + 1;
3568
3569 context->NumSources++;
3570 sublist->FreeMask &= ~(U64(1)<<slidx);
3571 almtx_unlock(&context->SourceLock);
3572
3573 return source;
3574 }
3575
3576 static void FreeSource(ALCcontext *context, ALsource *source)
3577 {
3578 ALCdevice *device = context->Device;
3579 ALuint id = source->id - 1;
3580 ALsizei lidx = id >> 6;
3581 ALsizei slidx = id & 0x3f;
3582 ALvoice *voice;
3583
3584 ALCdevice_Lock(device);
3585 if((voice=GetSourceVoice(source, context)) != NULL)
3586 {
3587 ATOMIC_STORE(&voice->Source, NULL, almemory_order_relaxed);
3588 ATOMIC_STORE(&voice->Playing, false, almemory_order_release);
3589 }
3590 ALCdevice_Unlock(device);
3591
3592 DeinitSource(source, device->NumAuxSends);
3593 memset(source, 0, sizeof(*source));
3594
3595 VECTOR_ELEM(context->SourceList, lidx).FreeMask |= U64(1) << slidx;
3596 context->NumSources--;
3597 }
3598
3599 /* ReleaseALSources
3600 *
3601 * Destroys all sources in the source map.
3602 */
3603 ALvoid ReleaseALSources(ALCcontext *context)
3604 {
3605 ALCdevice *device = context->Device;
3606 SourceSubList *sublist = VECTOR_BEGIN(context->SourceList);
3607 SourceSubList *subend = VECTOR_END(context->SourceList);
3608 size_t leftover = 0;
3609 for(;sublist != subend;++sublist)
3610 {
3611 ALuint64 usemask = ~sublist->FreeMask;
3612 while(usemask)
3613 {
3614 ALsizei idx = CTZ64(usemask);
3615 ALsource *source = sublist->Sources + idx;
3616
3617 DeinitSource(source, device->NumAuxSends);
3618 memset(source, 0, sizeof(*source));
3619 ++leftover;
3620
3621 usemask &= ~(U64(1) << idx);
3622 }
3623 sublist->FreeMask = ~usemask;
3624 }
3625 if(leftover > 0)
3626 WARN("(%p) Deleted "SZFMT" Source%s\n", device, leftover, (leftover==1)?"":"s");
3627 }
Software OpenAL implementation