Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/openal-0.0.8/src/al_source.c @ 17

Last change on this file since 17 was 17, checked in by landauf, 16 years ago
added openal
File size: 72.6 KB

Line
1	/* -- mode: C; tab-width:8; c-basic-offset:8 --
2	* vi:set ts=8:
3	*
4	* al_source.c
5	*
6	* Contains the implementation for source related functions like
7	* GenSource, DeleteSource, SourcePlay, etc, as well as internal
8	* use functions intended to manage the source structure.
9	*
10	*/
11	#include "al_siteconfig.h"
12
13	#include <AL/al.h>
14	#include <AL/alc.h>
15	#include <AL/alext.h>
16	#include <math.h>
17	#include <limits.h>
18	#include <stdio.h>
19	#include <stdlib.h>
20	#include <string.h>
21	#include <float.h>
22
23	#include "al_buffer.h"
24	#include "al_config.h"
25	#include "al_debug.h"
26	#include "al_error.h"
27	#include "al_main.h"
28	#include "al_mixer.h"
29	#include "al_spool.h"
30	#include "al_source.h"
31	#include "al_queue.h"
32	#include "al_types.h"
33	#include "al_vector.h"
34	#include "alc/alc_context.h"
35	#include "alc/alc_speaker.h"
36	#include "al_ext.h"
37
38	/*
39	* _alInitSource( ALuint sid )
40	*
41	* Initialize an already allocated source.
42	*/
43	static void _alInitSource( ALuint sid );
44
45	/*
46	* _alSource2D( AL_source *src )
47	*
48	* Turns off 3D attributes of a source
49	*/
50	static void _alSource2D( AL_source *src );
51
52	/*
53	* Monoify functions copy an interleaved array of PCM data, usually in LRLR
54	* format into seperate dst buffers.
55	*/
56	static void _alMonoifyOffset1to2(ALshort *dstref, ALuint offset, ALvoid src, ALuint ssize);
57	static void _alMonoifyOffset2to2(ALshort *dstref, ALuint offset, ALvoid src, ALuint ssize);
58	static void _alMonoifyOffset1to4(ALshort *dstref, ALuint offset, ALvoid src, ALuint ssize);
59	static void _alMonoifyOffset2to4(ALshort *dstref, ALuint offset, ALvoid src, ALuint ssize);
60	static void _alMonoifyOffset4to4(ALshort *dstref, ALuint offset, ALvoid src, ALuint ssize);
61
62	/*
63	* Channelify functions copy the PCM data from srcs[0..nc-1] into an
64	* interleaved destination. nc ( number of channels) is specified in the
65	* function name, ie _alChannelify2 specifies that srcs[0] and srcs[1] contain
66	* left and right channel data, respectively.
67	*/
68	static void _alChannelify2Offset(ALshort dst, ALuint offset, ALshort *srcs, ALuint size);
69	static void _alChannelify4Offset(ALshort dst, ALuint offset, ALshort *srcs, ALuint size);
70
71	/* static data */
72	static ALshort stereoptr = NULL; /
73	* scratch space for splitting multichannels
74	* sources.
75	*/
76
77	/*
78	* special split source to handle callbacks
79	*/
80	static void _alSplitSourceCallback(ALuint cid,
81	ALuint sourceid,
82	ALint nc, ALuint len,
83	AL_buffer *samp,
84	ALshort **buffers);
85	/*
86	* special split source to handle looping end case (wrap-around).
87	*/
88	static void _alSplitSourceLooping(ALuint cid,
89	ALuint sourceid,
90	ALint nc, ALuint len,
91	AL_buffer *samp,
92	ALshort **buffers);
93
94	/*
95	* special split source to handle buffer queue transitions
96	* (wrap-around).
97	*/
98	static void _alSplitSourceQueue(ALuint cid,
99	ALuint sourceid,
100	ALint nc, ALuint len,
101	AL_buffer *samp,
102	ALshort **buffers);
103
104	/*
105	* get a channel pointer into the buffer's data, scaled by the source's
106	* position into the PCM data.
107	*/
108	void _alSourceGetBufptr(AL_source src, AL_buffer *buf, ALuint ind);
109
110	/*
111	* alIsSource( ALuint sid )
112	*
113	* Returns AL_TRUE if sid is a currently valid source id,
114	* AL_FALSE otherwise.
115	*/
116	ALboolean alIsSource( ALuint sid )
117	{
118	ALboolean retval = AL_FALSE;
119
120	_alDCLockSource( sid );
121
122	retval = _alIsSource( sid );
123
124	_alDCUnlockSource( sid );
125
126	return retval;
127	}
128
129	/*
130	* _alIsSource( ALuint sid )
131	*
132	* Returns AL_TRUE if sid is a currently valid source id,
133	* AL_FALSE otherwise.
134	*
135	* Assumes locked source
136	*/
137	ALboolean _alIsSource( ALuint sid )
138	{
139	AL_source *src;
140	ALboolean retval = AL_TRUE;
141
142	src = _alDCGetSource( sid );
143	if(src == NULL) {
144	retval = AL_FALSE;
145	}
146
147	return retval;
148	}
149
150	/*
151	* alGenSources( ALsizei n, ALuint *buffer )
152	*
153	* Generate n sources, with sids in buffer[0..(n-1)]. Only
154	* full allocation is performed, with error being set otherwise.
155	*
156	* If n is 0, this is a legal nop. If n < 0, INVALID_VALUE is
157	* set and this is a nop.
158	*/
159	void alGenSources( ALsizei n, ALuint *buffer ) {
160	AL_context *cc;
161	ALint sindex;
162	ALuint *temp;
163	int i;
164
165	if( n == 0 ) {
166	/* with n == 0, we NOP */
167	return;
168	}
169
170	_alcDCLockContext();
171	cc = _alcDCGetContext();
172	if(cc == NULL)
173	{
174	/*
175	* alGenSources called without current context. Is there even
176	* an error for this?
177	*
178	* JIV FIXME: set some sort of error? Where?
179	*/
180
181	return;
182	}
183
184	if( n < 0 ) {
185	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
186	"alGenSources: illegal n value %d\n", n );
187
188	_alDCSetError( AL_INVALID_VALUE );
189	_alcDCUnlockContext();
190
191	return;
192	}
193
194	temp = malloc( n * sizeof *temp );
195	if(temp == NULL) {
196	/*
197	* Could not reserve memory for temporary
198	* ALuint *buffer.
199	*/
200	_alDCSetError( AL_OUT_OF_MEMORY );
201	_alcDCUnlockContext();
202
203	return;
204	}
205
206	for(i = 0; i < n; i++) {
207	sindex = spool_alloc( &cc->source_pool );
208	if( sindex == -1 ) {
209	/* We ran into a problem somewhere in
210	* allocing a set of source ids. Run
211	* through the ones we did alloc,
212	* realloc them, set error and return.
213	*
214	* FIXME: Should unlock, or have a non-locking
215	* version of alDelSources called inside
216	* the current lock?
217	*/
218	_alcDCUnlockContext();
219
220	if(i > 0) {
221	/*
222	* We delete i sources, and not i + 1, because
223	* the last alloc did not happen. And only
224	* if i > 0.
225	*/
226	alDeleteSources( i, temp );
227	}
228
229	free( temp );
230
231	_alDCSetError( AL_OUT_OF_MEMORY );
232
233	return;
234	}
235
236	temp[i] = sindex;
237	_alInitSource( temp[i] );
238	}
239
240	_alcDCUnlockContext();
241
242	/*
243	* temp[0...n-1] now contains the generated buffers. Copy them
244	* to the user data.
245	*/
246	memcpy( buffer, temp, n * sizeof *buffer );
247
248	free( temp );
249
250	return;
251	}
252
253	/*
254	* _alSource2D( AL_source *src )
255	*
256	* Turns off 3D attributes of a source
257	*
258	* Assumes locked source
259	*/
260	void _alSource2D( AL_source *src ) {
261	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
262	"_alSource2D: source turned 2D");
263
264	src->position.isset = AL_FALSE;
265	_alSourceGetParamDefault( AL_POSITION, src->position.data );
266
267	src->direction.isset = AL_FALSE;
268	_alSourceGetParamDefault( AL_DIRECTION, src->direction.data );
269
270	src->cone_inner_angle.isset = AL_FALSE;
271	_alSourceGetParamDefault( AL_CONE_INNER_ANGLE, &src->cone_inner_angle.data );
272
273	src->cone_outer_angle.isset = AL_FALSE;
274	_alSourceGetParamDefault( AL_CONE_OUTER_ANGLE, &src->cone_outer_angle.data );
275
276	src->cone_outer_gain.isset = AL_FALSE;
277	}
278
279	/*
280	* alSourcei( ALuint sid, ALenum param, ALint i1 )
281	*
282	* Sets an attribute for a source.
283	*
284	* If sid does not name a valid source, AL_INVALID_NAME.
285	* If param does not specify a source attribute, AL_INVALID_ENUM.
286	* If i1 is out of range for the attribute, AL_INVALID_VALUE.
287	*
288	* If param is AL_BUFFER, and the source in question is not in the state
289	* AL_INITIAL or AL_STOPPED, AL_INVALID_OPERATION.
290	*
291	*/
292	void alSourcei( ALuint sid, ALenum param, ALint i1 )
293	{
294	AL_source *src;
295	ALboolean inrange = AL_TRUE;
296	ALfloat temp;
297
298	/*
299	* If param refers to a integer attribute, accept it.
300	* If it refers to a float attribute, delegate it to alSourcefv. If
301	* it is an invalid attribute, set INVALID_ENUM and bail out.
302	*
303	* Float vectors are obviously not possible, so we set
304	* INVALID_OPERATION. This is probably a spec violation.
305	*/
306	switch( param ) {
307	case AL_BUFFER:
308	case AL_LOOPING:
309	case AL_SOURCE_RELATIVE:
310	/*
311	* We handle these natively.
312	*/
313	break;
314	case AL_PITCH:
315	case AL_MIN_GAIN:
316	case AL_MAX_GAIN:
317	case AL_CONE_INNER_ANGLE:
318	case AL_CONE_OUTER_ANGLE:
319	case AL_CONE_OUTER_GAIN:
320	case AL_GAIN:
321	case AL_GAIN_LINEAR_LOKI:
322	case AL_REFERENCE_DISTANCE:
323	case AL_ROLLOFF_FACTOR:
324	case AL_MAX_DISTANCE:
325	temp = i1;
326
327	alSourcef( sid, param, temp );
328
329	return;
330	break;
331	case AL_POSITION:
332	case AL_VELOCITY:
333	case AL_DIRECTION:
334	default:
335	_alcDCLockContext();
336	_alDCSetError( AL_INVALID_ENUM );
337	_alcDCUnlockContext();
338
339	return;
340	break;
341	}
342
343	SOURCELOCK();
344
345	src = _alDCGetSource( sid );
346	if(src == NULL) {
347	/*
348	* sid is invalid.
349	*/
350	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
351	"alSourcei: source id %d is not valid", sid);
352
353	_alDCSetError( AL_INVALID_NAME );
354
355	SOURCEUNLOCK();
356	return;
357	}
358
359	/*
360	* all calls to alSourcei specify ALboolean parameters,
361	* which means that i1 is either AL_TRUE, AL_FALSE, or
362	* not valid. So check for validity of i1 first, and
363	* set error if that's the case.
364	*/
365	switch( param ) {
366	case AL_LOOPING:
367	case AL_SOURCE_RELATIVE:
368	inrange = _alCheckRangeb( i1 );
369	break;
370	case AL_BUFFER:
371	inrange = alIsBuffer( i1 );
372
373	if( i1 == 0 ) {
374	/*
375	* bid of 0 has a special meaning: unset the
376	* parameter. So it's in range.
377	*/
378	inrange = AL_TRUE;
379	}
380	break;
381	default:
382	/* invalid param, error below. */
383	break;
384	}
385
386	if( inrange == AL_FALSE ) {
387	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
388	"alSourcei(%d, 0x%x, ...) called with invalid value %d",
389	sid, param, i1);
390
391	_alDCSetError( AL_INVALID_VALUE );
392
393	SOURCEUNLOCK();
394	return;
395	}
396
397	switch(param)
398	{
399	case AL_BUFFER:
400	switch( src->state )
401	{
402	case AL_PLAYING:
403	case AL_PAUSED:
404	/*
405	* Invalid state to set buffer in.
406	*/
407	_alDebug( ALD_SOURCE,
408	__FILE__, __LINE__,
409	"alSourcei(%d): source is playing, AL_BUFFER invalid",
410	sid );
411	_alDCSetError( AL_INVALID_OPERATION );
412	break;
413	default:
414	_alSourceQueueHead( src, i1 );
415	break;
416	}
417
418	break;
419	case AL_LOOPING:
420	src->looping.isset = AL_TRUE;
421	src->looping.data = i1;
422	break;
423	case AL_SOURCE_RELATIVE:
424	src->relative.isset = AL_TRUE;
425	src->relative.data = i1;
426	/* If this is a relative source with zero position,
427	perform the 2D sound hack...
428	(Tribes 2 reuses 3D sources as 2D sources)
429	*/
430	if ( i1 && src->position.isset &&
431	! src->position.data[0] &&
432	! src->position.data[1] &&
433	! src->position.data[2] ) {
434	_alSource2D(src);
435	}
436	break;
437	default:
438	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
439	"alSourcei: invalid or stubbed source param 0x%x",
440	param );
441
442	_alDCSetError( AL_INVALID_ENUM );
443	break;
444	}
445
446	SOURCEUNLOCK();
447
448	return;
449	}
450
451	/*
452	* alSourcef( ALuint sid, ALenum param, ALfloat f1 )
453	*
454	* Sets an attribute for a source.
455	*
456	* If sid does not name a valid source, AL_INVALID_NAME.
457	* If param does not specify a source attribute, AL_INVALID_ENUM.
458	* If f1 is out of range for the attribute, AL_INVALID_VALUE.
459	*
460	*/
461	void alSourcef( ALuint sid, ALenum param, ALfloat f1 ) {
462	/*
463	* If param refers to a integer attribute, delegate it to alSourcei.
464	* If it refers to a float attribute, delegate it to alSourcefv. If
465	* it is an invalid attribute, set INVALID_ENUM and bail out.
466	*
467	* Float vectors are obviously not possible, so we set
468	* INVALID_OPERATION. This is probably a spec violation.
469	*/
470	switch( param ) {
471	case AL_BUFFER:
472	case AL_LOOPING:
473	case AL_SOURCE_RELATIVE:
474	alSourcei( sid, param, (ALint) f1 );
475	return;
476	case AL_PITCH:
477	case AL_MIN_GAIN:
478	case AL_MAX_GAIN:
479	case AL_CONE_INNER_ANGLE:
480	case AL_CONE_OUTER_ANGLE:
481	case AL_CONE_OUTER_GAIN:
482	case AL_GAIN:
483	case AL_GAIN_LINEAR_LOKI:
484	case AL_REFERENCE_DISTANCE:
485	case AL_ROLLOFF_FACTOR:
486	case AL_MAX_DISTANCE:
487	alSourcefv( sid, param, &f1 );
488	return;
489	case AL_POSITION:
490	case AL_VELOCITY:
491	case AL_DIRECTION:
492	default:
493	_alcDCLockContext();
494	_alDCSetError( AL_INVALID_ENUM );
495	_alcDCUnlockContext();
496	return;
497	}
498	}
499
500	/*
501	* alSource3f( ALuint sid, ALenum param, ALfloat f1, ALfloat f2, ALfloat f3 )
502	*
503	* Sets an 3 float parameter for a source.
504	*
505	* If sid does not name a valid source, AL_INVALID_NAME.
506	* If param does not specify a source attribute, AL_INVALID_ENUM.
507	* If f1, f2, or f3 is out of range for the attribute, AL_INVALID_VALUE.
508	*
509	*/
510	void alSource3f( ALuint sid, ALenum param,
511	ALfloat f1, ALfloat f2, ALfloat f3 ) {
512	ALfloat fv[3];
513
514	fv[0] = f1;
515	fv[1] = f2;
516	fv[2] = f3;
517
518	alSourcefv( sid, param, fv );
519
520	return;
521	}
522
523	/*
524	* alSourcefv( ALuint sid, ALenum param, ALfloat fv )
525	*
526	* Sets an float vector parameter for a source.
527	*
528	* If sid does not name a valid source, AL_INVALID_NAME.
529	* If param does not specify a source attribute, AL_INVALID_ENUM.
530	* If any member of fv is out of range for the attribute, AL_INVALID_VALUE.
531	*
532	*/
533	void alSourcefv( ALuint sid, ALenum param, const ALfloat *fv1 )
534	{
535	AL_source *source;
536	ALboolean inrange = AL_TRUE;
537
538	/*
539	* If param refers to a integer attribute, delegate it to alSourcei.
540	* If it refers to a float attribute, we accept it.
541	*/
542	switch( param ) {
543	case AL_BUFFER:
544	case AL_LOOPING:
545	case AL_SOURCE_RELATIVE:
546	alSourcei( sid, param, (ALint) fv1[0] );
547	return;
548	case AL_PITCH:
549	case AL_MIN_GAIN:
550	case AL_MAX_GAIN:
551	case AL_CONE_INNER_ANGLE:
552	case AL_CONE_OUTER_ANGLE:
553	case AL_CONE_OUTER_GAIN:
554	case AL_GAIN:
555	case AL_GAIN_LINEAR_LOKI:
556	case AL_REFERENCE_DISTANCE:
557	case AL_ROLLOFF_FACTOR:
558	case AL_MAX_DISTANCE:
559	case AL_POSITION:
560	case AL_VELOCITY:
561	case AL_DIRECTION:
562	break;
563	default:
564	_alcDCLockContext();
565	_alDCSetError( AL_INVALID_ENUM );
566	_alcDCUnlockContext();
567	return;
568	}
569
570
571	SOURCELOCK();
572	source = _alDCGetSource( sid );
573
574	if( source == NULL ) {
575	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
576	"alSourcefv: %d is an invalid source id", sid );
577
578	_alDCSetError( AL_INVALID_NAME );
579
580	SOURCEUNLOCK();
581
582	return;
583	}
584
585	if( fv1 == NULL ) {
586	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
587	"alSourcefv: passed fv is NULL");
588
589	_alDCSetError( AL_INVALID_VALUE );
590
591	SOURCEUNLOCK();
592
593	return;
594	}
595
596	/* check to see if we are in range, first */
597	switch( param ) {
598	case AL_MIN_GAIN:
599	case AL_MAX_GAIN:
600	case AL_CONE_OUTER_GAIN:
601	case AL_GAIN:
602	case AL_GAIN_LINEAR_LOKI:
603	inrange = _alCheckRangef( fv1[0], 0.0, FLT_MAX );
604	break;
605	case AL_CONE_INNER_ANGLE:
606	case AL_CONE_OUTER_ANGLE:
607	inrange = _alCheckRangef( fv1[0], 0.0, 360.0 );
608	break;
609	case AL_PITCH:
610	/* FIXME: deviates from spec */
611	inrange = _alCheckRangef( fv1[0], 0.0, 2.0 );
612	break;
613	case AL_REFERENCE_DISTANCE:
614	case AL_MAX_DISTANCE:
615	case AL_ROLLOFF_FACTOR:
616	inrange = _alCheckRangef( fv1[0], 0.0, FLT_MAX );
617	break;
618	case AL_POSITION:
619	case AL_DIRECTION:
620	inrange = inrange && ( _alIsFinite( fv1[0] ) == AL_TRUE );
621	inrange = inrange && ( _alIsFinite( fv1[1] ) == AL_TRUE );
622	inrange = inrange && ( _alIsFinite( fv1[2] ) == AL_TRUE );
623
624	assert( inrange );
625	break;
626	default:
627	/* invalid param. error below */
628	break;
629	}
630
631	if( inrange == AL_FALSE ) {
632	/*
633	* We have a range error, exit early.
634	*/
635	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
636	"alSourcef(%d, 0x%x, ...): %f out of range",
637	sid, param, fv1[0] );
638
639	_alDCSetError( AL_INVALID_VALUE );
640
641	SOURCEUNLOCK();
642
643	return;
644	}
645
646	switch( param ) {
647	case AL_POSITION:
648	source->position.isset = AL_TRUE;
649	memcpy( &source->position.data, fv1, SIZEOFVECTOR );
650	/* If this is a relative source with zero position,
651	perform the 2D sound hack...
652	(Tribes 2 reuses 3D sources as 2D sources)
653	*/
654	if ( !fv1[0] && !fv1[1] && !fv1[2] &&
655	source->relative.isset &&
656	source->relative.data ) {
657	_alSource2D(source);
658	}
659	break;
660	case AL_DIRECTION:
661	/*
662	* The zero vector will make a directional sound
663	* non-directional.
664	*/
665	if(_alIsZeroVector(fv1) == AL_TRUE) {
666	/* clear DIRECTION flag */
667	source->direction.isset = AL_FALSE;
668	} else {
669	source->direction.isset = AL_TRUE;
670	memcpy( &source->direction.data, fv1, SIZEOFVECTOR );
671	}
672	break;
673	case AL_VELOCITY:
674	source->velocity.isset = AL_TRUE;
675	memcpy( &source->velocity.data, fv1, SIZEOFVECTOR );
676
677	/*
678	* velocity means doppler, which means that we
679	* need pitch, which means alf_tpitch takes care of
680	* incrementing soundpos. Very kludgey, I'll admit.
681	*
682	*/
683	source->flags \|= ALS_NEEDPITCH;
684	break;
685	case AL_MIN_GAIN:
686	source->min_gain.isset = AL_TRUE;
687	source->min_gain.data = fv1[0];
688	break;
689	case AL_MAX_GAIN:
690	source->max_gain.isset = AL_TRUE;
691	source->max_gain.data = fv1[0];
692	break;
693	case AL_CONE_INNER_ANGLE:
694	source->cone_inner_angle.isset = AL_TRUE;
695	source->cone_inner_angle.data = fv1[0];
696	break;
697	case AL_CONE_OUTER_ANGLE:
698	source->cone_outer_angle.isset = AL_TRUE;
699	source->cone_outer_angle.data = fv1[0];
700	break;
701	case AL_CONE_OUTER_GAIN:
702	source->cone_outer_gain.isset = AL_TRUE;
703	source->cone_outer_gain.data = fv1[0];
704	break;
705	case AL_PITCH:
706	/* only set pitch if it differs from 1.0 */
707	if(fv1[0] == 1.0) {
708	source->pitch.isset = AL_FALSE;
709	source->pitch.data = 1.0;
710
711	/*
712	* If velocity is set, then doppler may
713	* change the pitch.
714	*/
715	if (!source->velocity.isset) {
716	source->flags &= ~ALS_NEEDPITCH;
717	}
718	} else {
719	source->pitch.isset = AL_TRUE;
720	source->pitch.data = fv1[0];
721
722	/* tpitch messes with soundpos */
723	source->flags \|= ALS_NEEDPITCH;
724	}
725	break;
726	case AL_GAIN:
727	case AL_GAIN_LINEAR_LOKI:
728	source->gain.isset = AL_TRUE;
729	source->gain.data = fv1[0];
730	break;
731	case AL_REFERENCE_DISTANCE:
732	source->reference_distance.isset = AL_TRUE;
733	source->reference_distance.data = fv1[0];
734	break;
735	case AL_MAX_DISTANCE:
736	source->max_distance.isset = AL_TRUE;
737	source->max_distance.data = fv1[0];
738	break;
739	case AL_ROLLOFF_FACTOR:
740	source->rolloff_factor.isset = AL_TRUE;
741	source->rolloff_factor.data = fv1[0];
742	break;
743	default:
744	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
745	"alSourcefv(%d): param 0x%x not valid", sid, param );
746
747	_alDCSetError( AL_INVALID_ENUM );
748	break;
749	}
750
751	SOURCEUNLOCK();
752
753	return;
754	}
755
756	/*
757	* alGetSourcei( ALuint sid, ALenum pname, ALint *retref )
758	*
759	* Retrieve the value of a source (scalar) attribute
760	*
761	* If sid does not name a valid source, AL_INVALID_NAME.
762	* If param does not specify a source attribute, AL_INVALID_ENUM.
763	*
764	*/
765	void alGetSourcei( ALuint sid, ALenum param, ALint *retref )
766	{
767	ALint safety_first[6];
768
769	alGetSourceiv( sid, param, safety_first );
770
771	*retref = safety_first[0];
772
773	return;
774	}
775
776	/*
777	* alGetSourceiv( ALuint sid, ALenum pname, ALint *retref )
778	*
779	* Retrieve the value of a source attribute.
780	*
781	* If sid does not name a valid source, AL_INVALID_NAME.
782	* If param does not specify a source attribute, AL_INVALID_ENUM.
783	*
784	*/
785	void alGetSourceiv( ALuint sid, ALenum param, ALint *retref )
786	{
787	AL_source *src;
788	ALint *temp;
789
790	/*
791	* Check for invalid type request: eg AL_GAIN. We need
792	* to convert these.
793	*/
794	switch( param ) {
795	case AL_GAIN:
796	case AL_GAIN_LINEAR_LOKI:
797	case AL_CONE_INNER_ANGLE:
798	case AL_CONE_OUTER_ANGLE:
799	case AL_CONE_OUTER_GAIN:
800	case AL_PITCH:
801	case AL_REFERENCE_DISTANCE:
802	case AL_ROLLOFF_FACTOR:
803	case AL_MAX_DISTANCE:
804	/* float conversion */
805	do {
806	ALfloat ftemp = 0.0f;
807
808	alGetSourcefv( sid, param, &ftemp );
809
810	/* how do we know if we've failed? */
811	*retref = ftemp;
812
813	return;
814	} while(0);
815	break;
816	case AL_VELOCITY:
817	case AL_POSITION:
818	case AL_DIRECTION:
819	/* float conversion */
820	do {
821	ALfloat ftemp[3];
822
823	alGetSourcefv( sid, param, ftemp );
824
825	/* how do we know if we've failed? */
826	retref[0] = ftemp[0];
827	retref[1] = ftemp[1];
828	retref[2] = ftemp[2];
829
830	return;
831	} while(0);
832	break;
833	default:
834	/*
835	* either integer, boolean, or invalid
836	* param.
837	*/
838	break;
839	}
840
841	SOURCELOCK();
842	src = _alDCGetSource( sid );
843
844	if( src == NULL ) {
845	/*
846	* Invalid source id
847	*/
848	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
849	"alGetSourcei: invalid source id %d",
850	sid);
851
852	_alDCSetError( AL_INVALID_NAME );
853
854	SOURCEUNLOCK();
855	return;
856	}
857
858	if(retref == NULL) {
859	/* silently ignore */
860
861	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
862	"alGetSourcei(%d): NULL value", sid);
863
864	SOURCEUNLOCK();
865	return;
866	}
867
868
869	/*
870	* get param value, and store it in temp. We need it
871	* for most, but not all, of the following params enums.
872	*/
873	temp = _alGetSourceParam( src, param );
874	if(temp != NULL) {
875	/* If temp is not NULL, then there is a value set,
876	* and we don't have to slog through the defaults
877	* below.
878	*/
879
880	switch( param ) {
881	case AL_LOOPING:
882	case AL_SOURCE_RELATIVE:
883	retref = (ALboolean *) temp;
884	break;
885	default:
886	retref = temp;
887	break;
888	}
889
890	SOURCEUNLOCK();
891
892	return;
893	}
894
895	switch(param) {
896	case AL_BUFFERS_QUEUED:
897	/* AL_BUFFERS_QUEUED is not setable, and has no default. */
898	/* Following code incorrectly subtracts the number of
899	* processed buffers from the total number of buffers
900	* queued. We return the total number of buffers queued at
901	* all times.
902	*
903	* *retref = src->bid_queue.size - src->bid_queue.read_index;
904	*
905	* Following code correctly returns total number of buffers
906	* queued.
907	*/
908	if(src->bid_queue.size == 1)
909	{
910	/*
911	* Test to see if the only buffer queued is the 0
912	* buffer. If so, don't report it.
913	*/
914	if(src->bid_queue.queue[0] == 0)
915	{
916	*retref = 0;
917	}
918	else
919	{
920	/*
921	* There was only one bid but it wasn't the
922	* 0 buffer.
923	*/
924	*retref = 1;
925	}
926	}
927	else
928	{
929	/*
930	* More than one bid, not the 0 buffer. Or is it
931	* possible to stick it in there? Do we count it?
932	*
933	* JIV FIXME: check it out.
934	*/
935	*retref = src->bid_queue.size;
936	}
937	break;
938	case AL_BUFFERS_PROCESSED:
939	/* AL_BUFFERS_PROCESSED is not setable, and has no default. */
940
941	if( src->bid_queue.read_index == 0 ) {
942	/*
943	* We're still reading the first bid, so we haven't
944	* processed any yet. So return 0.
945	*/
946	*retref = 0;
947	} else {
948	*retref = src->bid_queue.read_index;
949	}
950	break;
951	#ifdef AL_SUPPORT_BYTE_LOKI_SOURCE_ATTR_
952	case AL_BYTE_LOKI:
953	/* AL_BYTE_LOKI is not setable, and has no default. */
954	switch(src->state) {
955	case AL_PLAYING:
956	case AL_PAUSED:
957	*retref = src->srcParams.soundpos;
958	break;
959	default:
960	*retref = -1;
961	break;
962	}
963	break;
964	#endif
965	case AL_SOURCE_STATE:
966	*retref = src->state;
967	break;
968	case AL_LOOPING:
969	case AL_SOURCE_RELATIVE:
970	/*
971	* These all have default states, but must be handled
972	* differently because they are booleans.
973	*/
974	{
975	ALboolean val;
976
977	_alSourceGetParamDefault( param, &val );
978
979	*retref = val;
980	}
981	break;
982	case AL_BUFFER:
983	/* These all have default states */
984	_alSourceGetParamDefault( param, retref );
985	break;
986	default:
987	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
988	"alGetSourcei: invalid or unsupported param 0x%x",
989	param);
990
991	_alDCSetError( AL_INVALID_ENUM );
992
993	break;
994	}
995
996	SOURCEUNLOCK();
997
998	return;
999	}
1000
1001	/*
1002	* alGetSource3f( ALuint sid, ALenum param,
1003	* ALfloat value1, ALfloat value2, ALfloat *value3)
1004	*
1005	* Retrieve the value of a (potentially) 3-tuple valued source attribute.
1006	*
1007	* If sid does not name a valid source, AL_INVALID_NAME.
1008	* If param does not specify a source attribute, AL_INVALID_ENUM.
1009	*/
1010	void alGetSource3f( ALuint sid, ALenum param,
1011	ALfloat value1, ALfloat value2, ALfloat *value3)
1012	{
1013	ALfloat safety_first[6];
1014
1015	if(( value1 == NULL ) &&
1016	( value2 == NULL ) &&
1017	( value3 == NULL ))
1018	{
1019	/* silently ignore */
1020	_alDebug( ALD_SOURCE, __FILE__, __LINE__,
1021	"alGetSource3f: value passed is NULL" );
1022
1023	return;
1024	}
1025
1026	alGetSourcefv( sid, param, safety_first );
1027
1028	if(value1)
1029	{
1030	*value1 = safety_first[0];
1031	}
1032
1033	if(value2)
1034	{
1035	*value2 = safety_first[1];
1036	}
1037
1038	if(value3)
1039	{
1040	*value3 = safety_first[2];
1041	}
1042
1043	return;
1044	}
1045
1046	/*
1047	* alGetSourcef( ALuint sid, ALenum param, ALfloat *value )
1048	*
1049	* Retrieve the value of a source attribute.
1050	*
1051	* If sid does not name a valid source, AL_INVALID_NAME.
1052	* If param does not specify a source attribute, AL_INVALID_ENUM.
1053	*/
1054	void alGetSourcef( ALuint sid, ALenum param, ALfloat *value )
1055	{
1056	ALfloat safety_first[6];
1057
1058	if( value == NULL )
1059	{
1060	/* silently ignore */
1061	_alDebug( ALD_SOURCE, __FILE__, __LINE__,
1062	"alGetSourcef: value passed is NULL" );
1063
1064	return;
1065	}
1066
1067	alGetSourcefv( sid, param, safety_first );
1068
1069	*value = safety_first[0];
1070
1071	return;
1072	}
1073
1074	/*
1075	* alGetSourcefv( ALuint sid, ALenum param, ALfloat *values )
1076	*
1077	* Retrieve the value of a source attribute.
1078	*
1079	* If sid does not name a valid source, AL_INVALID_NAME.
1080	* If param does not specify a source attribute, AL_INVALID_ENUM.
1081	*/
1082	void alGetSourcefv( ALuint sid, ALenum param, ALfloat *values ) {
1083	AL_source *src;
1084	ALfloat *srcvals;
1085	ALsizei numvalues; /* number of values to copy */
1086
1087	/*
1088	* Check for invalid type request: eg integer, boolean
1089	* or single float types.
1090	*
1091	* We need to convert these.
1092	*/
1093	switch( param ) {
1094	case AL_GAIN:
1095	case AL_GAIN_LINEAR_LOKI:
1096	case AL_CONE_INNER_ANGLE:
1097	case AL_CONE_OUTER_ANGLE:
1098	case AL_CONE_OUTER_GAIN:
1099	case AL_PITCH:
1100	case AL_REFERENCE_DISTANCE:
1101	case AL_MAX_DISTANCE:
1102	case AL_ROLLOFF_FACTOR:
1103	/* scalar param, only copy 1 value */
1104	numvalues = 1;
1105	break;
1106	case AL_LOOPING:
1107	case AL_SOURCE_RELATIVE:
1108	case AL_BUFFERS_QUEUED:
1109	case AL_BUFFERS_PROCESSED:
1110	#ifdef AL_SUPPORT_BYTE_LOKI_SOURCE_ATTR_
1111	case AL_BYTE_LOKI:
1112	#endif
1113	case AL_SOURCE_STATE:
1114	case AL_BUFFER:
1115	/* conversion to integer */
1116	do {
1117	ALint temp = 0;
1118
1119	alGetSourceiv( sid, param, &temp );
1120
1121	/*
1122	* how do we know if we've failed?
1123	*
1124	* only populate first entry
1125	*/
1126	*values = temp;
1127
1128	return;
1129	} while(0);
1130	break;
1131	default:
1132	/*
1133	* either float vector or invalid
1134	* param.
1135	*/
1136	numvalues = 3;
1137	break;
1138	}
1139
1140	SOURCELOCK();
1141	src = _alDCGetSource( sid );
1142
1143	if(src == NULL) {
1144	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1145	"alGetSourcefv: source id %d is invalid", sid);
1146
1147	_alDCSetError( AL_INVALID_NAME );
1148
1149	SOURCEUNLOCK();
1150	return;
1151	}
1152
1153	if( values == NULL ) {
1154	/* silently ignore */
1155
1156	_alDebug( ALD_SOURCE, __FILE__, __LINE__,
1157	"alGetSourcefv: values passed is NULL" );
1158
1159	SOURCEUNLOCK();
1160
1161	return;
1162	}
1163
1164	srcvals = _alGetSourceParam( src, param );
1165	if(srcvals != NULL) {
1166	/*
1167	* If srcvals is not NULL, then the attribute has been set by
1168	* the application, and we don't need to set defaults.
1169	*/
1170	memcpy( values, srcvals, numvalues * sizeof *values );
1171
1172	SOURCEUNLOCK();
1173
1174	return;
1175	}
1176
1177	/* If we are at this point, srcvals is NULL, which means
1178	* that either param is an invalid param, or that the value
1179	* is not set. Check for a valid param, in which case we
1180	* set the default, or set error.
1181	*/
1182	switch( param ) {
1183	/* scalars */
1184	case AL_GAIN:
1185	case AL_GAIN_LINEAR_LOKI:
1186	case AL_MIN_GAIN:
1187	case AL_MAX_GAIN:
1188	case AL_CONE_INNER_ANGLE:
1189	case AL_CONE_OUTER_ANGLE:
1190	case AL_CONE_OUTER_GAIN:
1191	case AL_PITCH:
1192	case AL_ROLLOFF_FACTOR:
1193	case AL_REFERENCE_DISTANCE:
1194	case AL_MAX_DISTANCE:
1195	case AL_VELOCITY:
1196	case AL_POSITION:
1197	case AL_DIRECTION:
1198	_alSourceGetParamDefault( param, values );
1199	break;
1200	default:
1201	_alDebug( ALD_SOURCE, __FILE__, __LINE__,
1202	"alGetSourcefv: param 0x%x either invalid or unset",
1203	param);
1204
1205	_alDCSetError( AL_INVALID_ENUM );
1206
1207	break;
1208	}
1209
1210	SOURCEUNLOCK();
1211
1212	return;
1213	}
1214
1215	/*
1216	* _alGetSource( ALuint cid, ALuint sid )
1217	*
1218	* Returns the address of the source sid from the
1219	* context cid, or NULL if the cid or sid is
1220	* invalid.
1221	*
1222	* Assumes locked context
1223	*/
1224	AL_source *_alGetSource( ALuint cid, ALuint sid ) {
1225	AL_context *cc;
1226
1227	cc = _alcGetContext( cid );
1228	if(cc == NULL) {
1229	/*
1230	* FIXME: Where, if at all, should be set the error?
1231	*/
1232	return NULL;
1233	}
1234
1235	return spool_index( &cc->source_pool, sid );
1236	}
1237
1238	/*
1239	* _alSplitSources( ALuint cid, ALuint sid,
1240	* ALint nc, ALuint len,
1241	* AL_buffer buf, ALshort *buffs );
1242	*
1243	* Populate buffs[0..nc-1][0..len/2-1] with data from buf, with offset into
1244	* buf given by the position associated with the source named by sid in the
1245	* context named by cid.
1246	*
1247	* This function delegates to static functions in the case of looping,
1248	* callback or queue sounds.
1249	*
1250	* assumes locked context
1251	*
1252	* FIXME: what an ugly mess
1253	*/
1254	void _alSplitSources( ALuint cid,
1255	ALuint sourceid,
1256	ALint nc, ALuint len,
1257	AL_buffer *samp,
1258	ALshort **buffers ) {
1259	AL_source *src;
1260	AL_sourcestate *srcstate;
1261	ALuint i;
1262	char *bufptr = NULL;
1263	static ALuint buflen = 0;
1264
1265	src = _alGetSource( cid, sourceid );
1266	if(src == NULL)
1267	{
1268	/* bad mojo */
1269	return;
1270	}
1271
1272	/*
1273	* if buflen is less that the passed len, this is probably
1274	* the first initialization and we need to allocate the
1275	* stereoptr (stereoptr being that buffer where we mix this
1276	* sort of thing).
1277	*
1278	* or buflen is equal to len and stereoptr is null because
1279	* the device was destroyed and then restarted.
1280	*/
1281	if(buflen < len \|\| stereoptr == NULL)
1282	{
1283	buflen = len;
1284
1285	stereoptr = realloc(stereoptr, buflen * 2);
1286
1287	memset( stereoptr, 0, buflen * 2 );
1288	}
1289
1290	if(stereoptr == NULL)
1291	{
1292	/* at this point, we're dead and don't know it. */
1293	return;
1294	}
1295
1296	/* Shouldn't happen. */
1297	if(len == 0) {
1298	_alDebug(ALD_SOURCE,
1299	__FILE__, __LINE__,
1300	"wtf? size = 0!!!!!!");
1301	_alDebug(ALD_SOURCE,
1302	__FILE__, __LINE__,
1303	"Expect SIGSEGV soon");
1304	return;
1305	}
1306
1307
1308	srcstate = _alSourceQueueGetCurrentState( src );
1309
1310	/*
1311	* If we have a callback function, read from it.
1312	*/
1313	if(samp->flags & ALB_CALLBACK)
1314	{
1315	srcstate->flags \|= ALQ_CALLBACKBUFFER;
1316
1317	_alSplitSourceCallback(cid, sourceid, nc, len, samp, buffers);
1318	return;
1319	} else {
1320	/* make sure we mark this as a normal buffer */
1321	srcstate->flags &= ~ALQ_CALLBACKBUFFER;
1322	}
1323
1324	if(_alSourceBytesLeftByChannel(src, samp) < (ALint) len)
1325	{
1326	if(_alSourceIsLooping(src) == AL_TRUE &&
1327	_alSourceIsQueue(src) == AL_FALSE )
1328	{
1329	/*
1330	* looping sources, when they need to wrap,
1331	* are handled via SplitSourceLooping.
1332	*/
1333	_alSplitSourceLooping(cid, sourceid,
1334	nc, len,
1335	samp,
1336	buffers);
1337
1338	return;
1339	}
1340
1341	if(_alSourceGetPendingBids(src) > 0)
1342	{
1343	/*
1344	* There are more buffers in the queue, so
1345	* do the wrapping.
1346	*/
1347	_alSplitSourceQueue(cid, sourceid,
1348	nc, len, samp, buffers);
1349
1350	return;
1351	}
1352
1353	len = _alSourceBytesLeftByChannel(src, samp);
1354
1355	if((len <= 0) \|\| (len > samp->size))
1356	{
1357	/* really short sound */
1358	len = samp->size;
1359
1360	return;
1361	}
1362	}
1363
1364	if(_alSourceGetPendingBids(src) > 0)
1365	assert(src->bid_queue.read_index < src->bid_queue.size );
1366
1367	for(i = 0; i < _alcGetNumSpeakers(cid); i++)
1368	{
1369	bufptr = _alSourceGetBufptr(src, samp, i);
1370
1371	memcpy(buffers[i], bufptr, len);
1372	}
1373
1374	return;
1375	}
1376
1377	/*
1378	* _alSplitSourceCallback( ALuint cid,
1379	* ALuint sourceid,
1380	* ALint nc, ALuint len,
1381	* AL_buffer *samp,
1382	* ALshort **buffers )
1383	*
1384	* Special SplitSource for callback sources, which need to have their
1385	* data populated not from the buffer's original data, but from the
1386	* callback.
1387	*/
1388	static void _alSplitSourceCallback( ALuint cid,
1389	ALuint sourceid,
1390	ALint nc, ALuint len,
1391	AL_buffer *samp,
1392	ALshort **buffers ) {
1393	AL_source *src;
1394	int *bid = NULL;
1395	ALuint nsamps = 0;
1396	int resultsamps = -1;
1397	int bufchannels = _alGetChannelsFromFormat( samp->format );
1398
1399	src = _alGetSource( cid, sourceid );
1400	if(src == NULL) {
1401	/*
1402	* Should we really be setting the error here?
1403	*/
1404	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1405	"_alSplitSourceCallback: invalid source id %d",
1406	sourceid);
1407
1408	_alSetError(cid, AL_INVALID_NAME);
1409	return;
1410	}
1411
1412	bid = (int *) _alGetSourceParam(src, AL_BUFFER);
1413	if(bid == NULL) {
1414	return;
1415	}
1416
1417	nsamps = bufchannels * len / sizeof **buffers;
1418
1419	resultsamps = samp->callback(sourceid, *bid,
1420	stereoptr,
1421	samp->format,
1422	samp->frequency,
1423	nsamps);
1424
1425	if(resultsamps < 0) {
1426	/* callback problem */
1427	_alDebug(ALD_STREAMING, __FILE__, __LINE__,
1428	"%d callback returned -1", sourceid);
1429
1430	memset(stereoptr, 0, len);
1431
1432	_alRemoveSourceFromMixer(sourceid);
1433
1434	return;
1435	}
1436
1437	if(resultsamps < (ALint) nsamps) {
1438	/* source is over */
1439	_alDebug(ALD_STREAMING, __FILE__, __LINE__,
1440	"time for %d to die", sourceid);
1441
1442	/* FIXME:
1443	*
1444	* offset memset at resultsamps / width to end
1445
1446	memset(stereoptr, 0, len);
1447	*/
1448
1449	/*
1450	* we want this to end. please.
1451	* What a cheat.
1452	*/
1453
1454	src->srcParams.soundpos = samp->size + nc * resultsamps * sizeof **buffers;
1455	}
1456
1457	/* set len to the number of bytes we actually got back
1458	* from the callback.
1459	*/
1460	len = resultsamps * sizeof **buffers / bufchannels;
1461
1462	/*
1463	* since we're decoding it, copy it to the orig_buffers so we only
1464	* have to do it once.
1465	*/
1466	_alMonoify(buffers, stereoptr, len, samp->num_buffers, bufchannels);
1467
1468	samp->size += nc * resultsamps * sizeof **buffers;
1469
1470	return;
1471	}
1472
1473	/*
1474	* _alSplitSourceLooping( ALuint cid,
1475	* ALuint sourceid,
1476	* ALint nc, ALuint len,
1477	* AL_buffer *samp,
1478	* ALshort **buffers )
1479	*
1480	* _alSplitSourceLooping is called to split a looping source that
1481	* has reached the loop point (ie, point where it needs to wrap around.
1482	*
1483	* This is very ugly, and needs to be cleaned up. I'd prefer not to
1484	* have a special case so if you're looking to contribute, please
1485	* consider redoing this.
1486	*
1487	* assumes locked context
1488	*
1489	* FIXME: this is so ugly.
1490	*/
1491	static void _alSplitSourceLooping( ALuint cid,
1492	ALuint sourceid,
1493	ALint nc, ALuint len,
1494	AL_buffer *samp,
1495	ALshort **buffers ) {
1496	AL_source *src;
1497	long mixable;
1498	long remaining;
1499	char *bufptr;
1500	int i;
1501	int bi;
1502	int bufchannels = _alGetChannelsFromFormat(samp->format);
1503	char *mdp;
1504
1505	src = _alGetSource(cid, sourceid);
1506	if(src == NULL) {
1507	/*
1508	* Should we really be setting the error here?
1509	*/
1510	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1511	"_alSplitSourceLooping: invalid source id %d",
1512	sourceid);
1513
1514	_alSetError(cid, AL_INVALID_NAME);
1515	return;
1516	}
1517
1518	mixable = _alSourceBytesLeftByChannel(src, samp);
1519	remaining = 0;
1520
1521	assert(mixable >= 0);
1522
1523	/* in case samp->size < len, we don't want
1524	* to overwrite with the memcpy
1525	*/
1526	if(len * bufchannels <= samp->size) {
1527	/* normal case */
1528	remaining = (len * bufchannels) - mixable;
1529
1530	for(i = 0; i < nc; i++) {
1531	bufptr = _alSourceGetBufptr(src, samp, i);
1532
1533	memcpy(buffers[i], bufptr, mixable);
1534	memcpy(buffers[i] + mixable/2, samp->orig_buffers[i],
1535	remaining);
1536	}
1537
1538	return;
1539	} else {
1540	/* really small looping sample */
1541	if(mixable < 0) {
1542	/* we loop sound in monoptr */
1543	mixable = src->srcParams.soundpos % len;
1544	}
1545
1546	for(bi = 0; bi < nc; bi++) {
1547	mdp = (char *) buffers[bi];
1548
1549	/* copy samp again and again */
1550	for(i = mixable; i < (signed int) len; i += samp->size) {
1551	int copylen;
1552
1553	if(i + samp->size < len) {
1554	copylen = samp->size;
1555	} else {
1556	copylen = len - i;
1557	}
1558
1559	memcpy(&mdp[i], samp->orig_buffers[bi], copylen);
1560	}
1561
1562	for(i = 0; i < mixable; i += samp->size) {
1563	int copylen;
1564
1565	if(i + samp->size < (unsigned int) mixable) {
1566	copylen = samp->size;
1567	} else {
1568	copylen = mixable - i;
1569	}
1570
1571	memcpy(&mdp[i],
1572	samp->orig_buffers[bi],
1573	copylen);
1574	}
1575	}
1576
1577	return;
1578	}
1579	#if 0
1580	/* ToDo: This is never reached?! */
1581	for(i = 0; i < nc; i++) {
1582	bufptr = _alSourceGetBufptr(src, samp, i);
1583
1584	memcpy(buffers[i], bufptr, len);
1585	}
1586	#endif
1587	}
1588
1589	/*
1590	* _alSplitSourceQueue( ALuint cid,
1591	* ALuint sourceid,
1592	* ALint nc, ALuint len,
1593	* AL_buffer *samp,
1594	* ALshort **buffers )
1595	*
1596	* _alSplitSourceQueue is called to ease the transition between
1597	* buffers in a source's queue.
1598	*
1599	* This is very ugly, and needs to be cleaned up. I'd prefer not to
1600	* have a special case so if you're looking to contribute, please
1601	* consider redoing this.
1602	*
1603	* assumes locked context
1604	*
1605	* FIXME: this is so ugly.
1606	*/
1607	static void _alSplitSourceQueue( ALuint cid,
1608	ALuint sourceid,
1609	ALint nc, ALuint len,
1610	AL_buffer *samp,
1611	ALshort **buffers )
1612	{
1613	AL_source *src;
1614	AL_buffer *nextsamp;
1615	long mixable;
1616	ALuint remaining;
1617	char *bufptr;
1618	ALuint nextbid;
1619	void *nextpcm;
1620	int new_soundpos = -1;
1621	int old_soundpos;
1622	int old_readindex;
1623	ALuint collected_bytes = 0;
1624	int i;
1625
1626	src = _alGetSource(cid, sourceid);
1627	if(src == NULL)
1628	{
1629	/*
1630	* Should we really be setting the error here?
1631	*/
1632	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1633	"_alSplitSourceQueue: invalid source id %d",
1634	sourceid);
1635
1636	_alSetError(cid, AL_INVALID_NAME);
1637	return;
1638	}
1639
1640	old_soundpos = src->srcParams.soundpos;
1641	old_readindex = src->bid_queue.read_index;
1642
1643	#if 1
1644	if( _alSourceBytesLeftByChannel(src, samp) <= 0)
1645	{
1646
1647	ALuint bid = 0;
1648
1649	/* no data left in this buffer */
1650	src->bid_queue.read_index++;
1651	if(src->bid_queue.read_index >= src->bid_queue.size)
1652	{
1653	/* JIV FIXME: breaks queue looping? */
1654	if(_alSourceIsLooping(src))
1655	{
1656	src->bid_queue.read_index = 0;
1657	}
1658	else
1659	{
1660	/* JIV FIXME: doesn't mix last queue bit */
1661
1662	return;
1663	}
1664	}
1665
1666	bid = src->bid_queue.queue[src->bid_queue.read_index];
1667	samp = _alGetBuffer(bid);
1668	if(samp == NULL)
1669	{
1670	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1671	"_alSplitSourceQueue: null buffer");
1672
1673	return;
1674	}
1675
1676	src->srcParams.soundpos = 0;
1677
1678	/* ho ho ho ho */
1679	_alSplitSources(cid, sourceid, nc, len, samp, buffers);
1680	return;
1681	}
1682	#endif
1683
1684	nextbid = src->bid_queue.queue[src->bid_queue.read_index + 1];
1685	nextsamp = _alGetBuffer(nextbid);
1686	if(nextsamp == NULL)
1687	{
1688	/*
1689	* Should we really be setting the error here?
1690	*/
1691	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1692	"_alSplitSourceQueue: shouldn't happen");
1693
1694	return;
1695	}
1696
1697	/* assert(len >= 0); */
1698	/* assert(src->srcParams.soundpos >= 0); */
1699
1700	/*
1701	*
1702	* First, test whether we can get enough data to fill the
1703	* request with the current buffer's data ( minus current sound
1704	* pos ) plus the next buffer's data.
1705	*/
1706	if( samp->size + nextsamp->size >= len + src->srcParams.soundpos )
1707	{
1708	#ifdef DEBUG_QUEUE
1709	_alDebug(ALD_QUEUE, __FILE__, __LINE__,
1710	"Queue filling from two buffers ( size + nextsize (%d) vs soundpos + len %d",
1711	samp->size + nextsamp->size,
1712	len + src->srcParams.soundpos);
1713	#endif
1714
1715	/* we can fill the request */
1716	mixable = _alSourceBytesLeftByChannel(src, samp);
1717	remaining = 0;
1718
1719	assert( mixable >= 0 );
1720
1721	/*
1722	* in case samp->size < len, we don't want
1723	* to overwrite with the memcpy
1724	*/
1725	remaining = len - mixable;
1726
1727	#ifdef DEBUG_QUEUE
1728	_alDebug(ALD_QUEUE, __FILE__, __LINE__,
1729	"first buffer %d, second buffer %d",
1730	mixable, remaining);
1731	#endif
1732
1733
1734	for(i = 0; i < nc; i++) {
1735	bufptr = _alSourceGetBufptr(src, samp, i);
1736	nextpcm = nextsamp->orig_buffers[i];
1737
1738	memcpy(buffers[i], bufptr, mixable);
1739	memcpy(buffers[i] + mixable/2, nextpcm, remaining);
1740	}
1741
1742	src->srcParams.new_readindex = src->bid_queue.read_index + 1;
1743	src->srcParams.new_soundpos = remaining;
1744
1745	if(remaining >= nextsamp->size)
1746	{
1747	/* we read all of the next buffer */
1748	src->srcParams.new_readindex++;
1749	}
1750
1751	#ifdef DEBUG_QUEUE
1752	_alDebug(ALD_QUEUE, __FILE__, __LINE__,
1753	"SplitSourceQueue, read_index is now %d",
1754	src->srcParams.new_readindex);
1755	#endif
1756
1757	return;
1758	}
1759
1760	#ifdef DEBUG_QUEUE
1761	fprintf(stderr, "Splitting from multiple needed %d left %d\n",
1762	len,
1763	samp->size - src->srcParams.soundpos);
1764	#endif
1765
1766	/*
1767	* We need to get data from more than one buffer
1768	*/
1769	while( collected_bytes < len )
1770	{
1771	int bid;
1772
1773	if( src->bid_queue.read_index >= src->bid_queue.size )
1774	{
1775	#ifdef DEBUG_QUEUE
1776	fprintf(stderr, "end of buffer queue\n" );
1777	#endif
1778
1779	/*
1780	* Read past the last buffer and we still
1781	* have to write out. Pad the rest with silence,
1782	* I guess. Do we support looping queued buffers?
1783	*/
1784	for(i = 0; i < nc; i++)
1785	{
1786	memset(buffers[i] + collected_bytes/2,
1787	0, len - collected_bytes);
1788	}
1789
1790	src->bid_queue.read_index = old_readindex;
1791	src->srcParams.soundpos = old_soundpos;
1792
1793	return;
1794	}
1795
1796	assert(src->bid_queue.read_index < src->bid_queue.size );
1797
1798	bid = src->bid_queue.queue[src->bid_queue.read_index];
1799	samp = _alGetBuffer(bid);
1800
1801	mixable = samp->size - src->srcParams.soundpos;
1802
1803	if(mixable > (int) (len - collected_bytes))
1804	{
1805	mixable = len - collected_bytes;
1806	new_soundpos = src->srcParams.soundpos + mixable;
1807	}
1808	else
1809	{
1810	src->bid_queue.read_index++;
1811	new_soundpos = 0;
1812	}
1813
1814	/* copy from current buffer */
1815	for(i = 0; i < nc; i++)
1816	{
1817	bufptr = _alSourceGetBufptr(src, samp, i);
1818
1819	memcpy(buffers[i] + collected_bytes/2, bufptr, mixable);
1820	}
1821
1822	collected_bytes += mixable;
1823
1824	src->srcParams.soundpos = new_soundpos;
1825	}
1826
1827	src->srcParams.new_readindex = src->bid_queue.read_index;
1828	src->srcParams.new_soundpos = new_soundpos;
1829
1830	src->bid_queue.read_index = old_readindex;
1831	src->srcParams.soundpos = old_soundpos;
1832
1833	return;
1834	}
1835
1836	/*
1837	* _alMonoifyOffset( ALshort **dstref, ALuint offset,
1838	* ALvoid *src, ALuint src_size,
1839	* ALuint dest_channels, ALuint src_channels )
1840	*
1841	* Copies the interleaved data from src[0..(src_size/2)-1] to
1842	* dstret[0..dest_channels-1], splitting it into seperate channels.
1843	* src_channels describes the period of the channel repetition in src,
1844	* dest_channels describes the number of independant buffers in dstref.
1845	* src_size is the size of src in bytes, and offset is the offset into each
1846	* seperate channel in dstref where the copying begins.
1847	*
1848	* assumes locked context
1849	*/
1850	void _alMonoifyOffset(ALshort **dstref, ALuint offset,
1851	ALvoid *srcp, ALuint size, ALuint dc, ALuint sc) {
1852	switch( dc ) {
1853	case 4:
1854	switch(sc) {
1855	case 1:
1856	_alMonoifyOffset1to4(dstref, offset, srcp, size);
1857	break;
1858	case 2:
1859	_alMonoifyOffset2to4(dstref, offset, srcp, size);
1860	break;
1861	case 4:
1862	_alMonoifyOffset4to4(dstref, offset, srcp, size);
1863	break;
1864	default:
1865	fprintf(stderr, "unhandled Monoify (dc %d sc %d)\n",
1866	dc, sc);
1867	break;
1868	}
1869	break;
1870	case 2:
1871	switch(sc) {
1872	case 1:
1873	_alMonoifyOffset1to2(dstref, offset, srcp, size);
1874	break;
1875	case 2:
1876	_alMonoifyOffset2to2(dstref, offset, srcp, size);
1877	break;
1878	default:
1879	fprintf(stderr, "unhandled Monoify (dc %d sc %d)\n",
1880	dc, sc);
1881	break;
1882	}
1883	break;
1884	case 1:
1885	switch(sc) {
1886	case 1:
1887	memcpy((char ) dstref + offset, srcp, size);
1888	break;
1889	default:
1890	fprintf(stderr, "unhandled Monoify (dc %d sc %d)\n",
1891	dc, sc);
1892	break;
1893	}
1894	break;
1895	default:
1896	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
1897	"Unhandled dc %d", dc);
1898	break;
1899	}
1900
1901	return;
1902	}
1903
1904	static void _alMonoifyOffset1to4( ALshort **dsts, ALuint offset,
1905	ALvoid *srcp, ALuint size) {
1906	ALshort src = (ALshort ) srcp;
1907	ALshort *dst0 = dsts[0];
1908	ALshort *dst1 = dsts[1];
1909	ALshort *dst2 = dsts[2];
1910	ALshort *dst3 = dsts[3];
1911
1912	int len = size / sizeof *src;
1913	int i;
1914
1915	offset /= sizeof **dsts;
1916	dst0 += offset;
1917	dst1 += offset;
1918	dst2 += offset;
1919	dst3 += offset;
1920
1921	for(i = 0; i < len; i++) {
1922	dst0[i] = src[0];
1923	dst1[i] = src[0];
1924	dst2[i] = src[0];
1925	dst3[i] = src[0];
1926
1927	src++;
1928	}
1929
1930	return;
1931	}
1932
1933
1934
1935	static void _alMonoifyOffset2to4( ALshort **dsts, ALuint offset,
1936	ALvoid *srcp, ALuint size) {
1937	ALshort src = (ALshort ) srcp;
1938	ALshort *dst0 = dsts[0];
1939	ALshort *dst1 = dsts[1];
1940	ALshort *dst2 = dsts[2];
1941	ALshort *dst3 = dsts[3];
1942
1943	int len = size / sizeof *src;
1944	int i;
1945
1946	offset /= sizeof **dsts;
1947	dst0 += offset;
1948	dst1 += offset;
1949	dst2 += offset;
1950	dst3 += offset;
1951
1952	for(i = 0; i < len; i++) {
1953	dst0[i] = src[0];
1954	dst1[i] = src[1];
1955	dst2[i] = src[0];
1956	dst3[i] = src[1];
1957
1958	src += 2;
1959	}
1960
1961	return;
1962	}
1963
1964
1965
1966	static void _alMonoifyOffset4to4( ALshort **dsts, ALuint offset,
1967	ALvoid *srcp, ALuint size) {
1968	ALshort src = (ALshort ) srcp;
1969	ALshort *dst0 = dsts[0];
1970	ALshort *dst1 = dsts[1];
1971	ALshort *dst2 = dsts[2];
1972	ALshort *dst3 = dsts[3];
1973
1974	int len = size / sizeof *src;
1975	int i;
1976
1977	offset /= sizeof **dsts;
1978	dst0 += offset;
1979	dst1 += offset;
1980	dst2 += offset;
1981	dst3 += offset;
1982
1983	for(i = 0; i < len; i++) {
1984	dst0[i] = src[0];
1985	dst1[i] = src[1];
1986	dst2[i] = src[2];
1987	dst3[i] = src[3];
1988
1989	src += 4;
1990	}
1991
1992	return;
1993	}
1994
1995
1996	/*
1997	* _alMonoifyOffset1to2( ALshort **dsts, ALuint offset,
1998	* ALvoid *srcp, ALuint size)
1999	*
2000	* Helper function for _alMonoifyOffset. Converts from stereo to 2 channels
2001	* of buffer data.
2002	*/
2003	static void _alMonoifyOffset1to2( ALshort **dsts, ALuint offset,
2004	ALvoid *srcp, ALuint size) {
2005	ALshort src = (ALshort ) srcp;
2006	ALshort *dst0 = dsts[0];
2007	ALshort *dst1 = dsts[1];
2008	int len = size / sizeof *src;
2009	int i;
2010
2011	offset /= sizeof **dsts;
2012	dst0 += offset;
2013	dst1 += offset;
2014
2015	for(i = 0; i < len; i++) {
2016	dst0[i] = src[0];
2017	dst1[i] = src[0];
2018
2019	src++;
2020	}
2021
2022	return;
2023	}
2024
2025	/*
2026	* _alMonoifyOffset2to2( ALshort **dsts, ALuint offset,
2027	* ALvoid *srcp, ALuint size )
2028	*
2029	* Helper function for _alMonoifyOffset. Converts from stereo to 2 channels
2030	* of buffer data.
2031	*/
2032	static void _alMonoifyOffset2to2( ALshort **dsts, ALuint offset,
2033	ALvoid *srcp, ALuint size) {
2034	ALshort src = (ALshort ) srcp;
2035	ALshort *dst0 = dsts[0];
2036	ALshort *dst1 = dsts[1];
2037	int len = size / sizeof *src;
2038	int i;
2039
2040	offset /= sizeof **dsts;
2041
2042	dst0 += offset;
2043	dst1 += offset;
2044
2045	for(i = 0; i < len; i++) {
2046	dst0[i] = src[0];
2047	dst1[i] = src[1];
2048
2049	src += 2;
2050	}
2051
2052	return;
2053	}
2054
2055	/*
2056	* _alChannelifyOffset( ALshort *dst, ALuint offset,
2057	* ALshort **srcs, ALuint size, ALuint nc )
2058	*
2059	* This function is sort of the complement of _alMonoifyOffset. Data is
2060	* copied from srcs[0..nc-1][offset/2..(offset + size)/2-1] into an
2061	* interleaved array dst.
2062	*
2063	* assumes locked context
2064	*
2065	* FIXME: handle cases with > 2 channels
2066	*/
2067	void _alChannelifyOffset( ALshort *dst, ALuint offset,
2068	ALshort **srcs, ALuint size, ALuint nc )
2069	{
2070	switch( nc )
2071	{
2072	case 4:
2073	_alChannelify4Offset(dst, offset, srcs, size);
2074	break;
2075	case 2:
2076	_alChannelify2Offset(dst, offset, srcs, size);
2077	break;
2078	case 1:
2079	memcpy( dst, srcs[0] + offset/sizeof *srcs, size );
2080	break;
2081	default:
2082	break;
2083	}
2084
2085	return;
2086	}
2087
2088	/*
2089	* _alChannelify2Offset( ALshort *dst, ALuint offset,
2090	* ALshort **srcs, ALuint size )
2091	*
2092	* This function is like ChannelifyOffset, but specificly for those cases
2093	* where the number of channels in srcs is 2.
2094	*
2095	* assumes locked context
2096	*/
2097	void _alChannelify2Offset( ALshort *dst, ALuint offset,
2098	ALshort **srcs, ALuint size ) {
2099	ALshort src0 = &srcs[0][offset / sizeof srcs];
2100	ALshort src1 = &srcs[1][offset / sizeof srcs];
2101	ALuint k;
2102
2103	size /= sizeof dst; / we need sample offsets */
2104
2105	for( k = 0; k < size; k++ ) {
2106	dst[0] = src0[k];
2107	dst[1] = src1[k];
2108
2109	dst += 2;
2110	}
2111
2112	return;
2113	}
2114
2115	/*
2116	* _alChannelify4Offset( ALshort *dst, ALuint offset,
2117	* ALshort **srcs, ALuint size )
2118	*
2119	* This function is like ChannelifyOffset, but specificly for those cases
2120	* where the number of channels in srcs is 4.
2121	*
2122	* assumes locked context
2123	*/
2124	void _alChannelify4Offset( ALshort *dst, ALuint offset,
2125	ALshort **srcs, ALuint size ) {
2126	ALshort src0 = &srcs[0][offset / sizeof srcs];
2127	ALshort src1 = &srcs[1][offset / sizeof srcs];
2128	ALshort src2 = &srcs[2][offset / sizeof srcs];
2129	ALshort src3 = &srcs[3][offset / sizeof srcs];
2130	ALuint k;
2131
2132	size /= sizeof dst; / we need sample offsets */
2133
2134	for( k = 0; k < size; k++ ) {
2135	dst[0] = src0[k];
2136	dst[1] = src1[k];
2137	dst[2] = src2[k];
2138	dst[3] = src3[k];
2139
2140	dst += 4;
2141	}
2142
2143	return;
2144	}
2145
2146
2147
2148	/*
2149	* alDeleteSources( ALsizei n, ALuint *sources )
2150	*
2151	* Delete n sources, with sids located in sources[0..n-1]. Only full
2152	* deallocations are possible, and if one of sources[0..n-1] is not a
2153	* valid source id (or is currently in an active state), and error is
2154	* set and no deallocation occurs.
2155	*
2156	* If n is 0, this is a legal nop. If n < 0, INVALID_VALUE is set
2157	* and this is a nop.
2158	*/
2159	void alDeleteSources( ALsizei n, const ALuint *sources ) {
2160	AL_source *src;
2161	AL_context *cc;
2162	int i;
2163
2164	if(n == 0) {
2165	/* silently return */
2166	return;
2167	}
2168
2169	if(n < 0) {
2170	_alDebug(ALD_BUFFER, __FILE__, __LINE__,
2171	"alDeleteSources: invalid n %d\n", n);
2172
2173	_alDCSetError(AL_INVALID_VALUE);
2174	return;
2175	}
2176
2177	_alcDCLockContext();
2178
2179	cc = _alcDCGetContext();
2180	if(cc == NULL) {
2181	/*
2182	* No current context with which to evaluate the
2183	* validity of the sources
2184	*/
2185	_alcDCUnlockContext();
2186	return;
2187	}
2188
2189	for(i = 0; i < n; i++) {
2190	src = _alDCGetSource( sources[i] );
2191	if(src == NULL) {
2192	/* invalid source id, return. */
2193	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
2194	"alDeleteSources: invalid source %d",
2195	sources[i]);
2196
2197	_alDCSetError( AL_INVALID_NAME );
2198	_alcDCUnlockContext();
2199
2200	return;
2201	}
2202
2203	if((src->state == AL_PLAYING) \|\| (src->state == AL_PAUSED)) {
2204	/*
2205	* FIXME: illegal to delete playing source?
2206	*/
2207	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
2208	"alDeleteSources: tried to delete playing/paused source %d",
2209	sources[i]);
2210
2211	_alDCSetError(AL_INVALID_OPERATION);
2212	_alcDCUnlockContext();
2213	return;
2214	}
2215
2216	}
2217
2218	for(i = 0; i < n; i++) {
2219	src = _alDCGetSource(sources[i]);
2220	if(src == NULL) {
2221	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
2222	"alDeleteSources: invalid source %d",
2223	sources[i]);
2224
2225	_alDCSetError(AL_INVALID_NAME);
2226	continue;
2227	}
2228
2229	if(src->state == AL_PLAYING) {
2230	/*
2231	* FIXME: illegal to delete playing source?
2232	*/
2233	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
2234	"alDeleteSources: tried to del playing source %d",
2235	sources[i]);
2236
2237	_alDCSetError(AL_INVALID_OPERATION);
2238	continue;
2239	}
2240
2241	spool_dealloc(&cc->source_pool, sources[i],
2242	_alDestroySource);
2243	}
2244
2245	_alcDCUnlockContext();
2246	return;
2247	}
2248
2249	/*
2250	* _alDestroySources
2251	*
2252	* This destructor is responsible for deallocating source data structures
2253	* after openal has finished.
2254	*/
2255	void _alDestroySources(spool_t *spool) {
2256	ALuint i;
2257
2258	for( i = 0; i < spool->size; i++ ) {
2259	_alDestroyMutex( spool->smutexen[i] );
2260	}
2261
2262
2263	spool_free( spool, _alDestroySource );
2264
2265	free( spool->smutexen );
2266	free( stereoptr );
2267
2268	spool->smutexen = NULL;
2269	stereoptr = NULL;
2270
2271	return;
2272	}
2273
2274	/*
2275	* _alDestroySource
2276	*
2277	* Deallocates the memory associated with an AL_source, passed as a void *
2278	* to this function.
2279	*
2280	* assumes locked context
2281	*/
2282	void _alDestroySource( void *srcp ) {
2283	AL_source src = (AL_source ) srcp;
2284	ALuint *bidp;
2285	int i;
2286
2287	/*
2288	* if we have a callback buffer, call the
2289	* destructor with the "free one source" args
2290	*/
2291	bidp = _alGetSourceParam(src, AL_BUFFER);
2292	if(bidp != NULL) {
2293	if(_alBidIsCallback(*bidp) == AL_TRUE) {
2294	_alBidCallDestroyCallbackSource(src->sid);
2295	}
2296	}
2297
2298	/* deallocation per source scratch space */
2299	free(src->srcParams.outbuf);
2300	src->srcParams.outbuf = NULL;
2301
2302	for(i = _alcDCGetNumSpeakers() - 1; i >= 0; i--) {
2303	if(src->reverb_buf[i] != NULL) {
2304	/* deallocation reverb scratch space */
2305	free( src->reverb_buf[i] );
2306	src->reverb_buf[i] = NULL;
2307	}
2308	}
2309
2310	free( src->bid_queue.queuestate );
2311	free( src->bid_queue.queue );
2312
2313	src->bid_queue.queue = NULL;
2314	src->bid_queue.queuestate = NULL;
2315	src->bid_queue.size = 0;
2316
2317	return;
2318	}
2319
2320	/*
2321	* alSourcePause( ALuint sid )
2322	*
2323	* If sid is a valid source name, then if the source associated with it has
2324	* the state AL_PLAYING, it will be taken to the state AL_PAUSED.
2325	*
2326	* If sid is not a valid source name, set AL_INVALID_NAME.
2327	*/
2328	void alSourcePause( ALuint sid ) {
2329	alSourcePausev( 1, &sid );
2330
2331	return;
2332	}
2333
2334	/*
2335	* alSourcePlay( ALuint sid )
2336	*
2337	* If sid is a valid source name, then if the source associated with it has
2338	* the state AL_INITAL, AL_PAUSED, or AL_STOPPED, it will be taken to the
2339	* state AL_PLAYING.
2340	*
2341	* If sid is not a valid source name, set AL_INVALID_NAME.
2342	*/
2343	void alSourcePlay( ALuint sid ) {
2344	alSourcePlayv( 1, &sid );
2345
2346	return;
2347	}
2348
2349	/*
2350	* alSourceStop( ALuint sid )
2351	*
2352	* If sid is a valid source name, then if the source associated with it has
2353	* the state AL_PLAYING or AL_PAUSED it will be taken to the state AL_STOPPED.
2354	*
2355	* If sid is not a valid source name, set AL_INVALID_NAME.
2356	*/
2357	void alSourceStop( ALuint sid ) {
2358	alSourceStopv( 1, &sid );
2359
2360	return;
2361	}
2362
2363	/*
2364	* alSourceRewind( ALuint sid )
2365	*
2366	* If sid is a valid source name, then if the source associated with it has
2367	* the state AL_PLAYING, AL_PAUSED or AL_STOPPED, it will be taken to the
2368	* state AL_INITAL.
2369	*
2370	* If the source is playing or paused, it will first be stopped.
2371	*
2372	* If sid is not a valid source name, set AL_INVALID_NAME.
2373	*/
2374	void alSourceRewind( ALuint sid ) {
2375	alSourceRewindv( 1, &sid );
2376
2377	return;
2378	}
2379
2380	/*
2381	* alSourceRewindv( ALsizei ns, ALuint *sids )
2382	*
2383	* If ns == 0, legal NOP.
2384	* If ns < 0, sets AL_INVALID_VALUE.
2385	*
2386	* If sids[0..ns-1] are all valid source names, then for each source with
2387	* state AL_PLAYING, AL_PAUSED or AL_STOPPER change the state to AL_INITAL.
2388	* If sources are playing or paused, they will first be stopped.
2389	*
2390	* If any member of sids[0..ns-1] is not a valid source name, set
2391	* AL_INVALID_NAME.
2392	*/
2393	void alSourceRewindv( ALsizei ns, const ALuint *sids ) {
2394	AL_source *src;
2395	ALsizei i;
2396
2397	if( ns == 0 ) {
2398	/* legal NOP */
2399	return;
2400	}
2401
2402	if( ns < 0 ) {
2403	/* set error */
2404	_alcDCLockContext();
2405	_alDCSetError( AL_INVALID_VALUE );
2406	_alcDCUnlockContext();
2407
2408	return;
2409	}
2410
2411	SOURCELOCK();
2412
2413	/* validate */
2414	for( i = 0; i < ns; i++ ) {
2415	if( _alIsSource( sids[i] ) == AL_FALSE ) {
2416	_alDCSetError( AL_INVALID_NAME );
2417
2418	SOURCEUNLOCK();
2419
2420	return;
2421	}
2422	}
2423
2424	_alLockMixBuf();
2425
2426	for( i = 0; i < ns; i++ ) {
2427	src = _alDCGetSource( sids[i] );
2428	if(src == NULL) {
2429	/* shouldn't happen */
2430	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
2431	"alSourceRewindv: source id %d is invalid",
2432	sids[i] );
2433
2434	_alDCSetError( AL_INVALID_NAME );
2435
2436	SOURCEUNLOCK();
2437	return;
2438	}
2439
2440
2441	switch( src->state ) {
2442	case AL_INITIAL:
2443	/* legal NOP */
2444	break;
2445	case AL_PAUSED:
2446	case AL_PLAYING:
2447	_alRemoveSourceFromMixer( sids[i] );
2448	case AL_STOPPED:
2449	src->state = AL_INITIAL;
2450	src->srcParams.soundpos = 0;
2451	break;
2452	}
2453	}
2454
2455	_alUnlockMixBuf();
2456
2457	SOURCEUNLOCK();
2458
2459	return;
2460	}
2461
2462	/*
2463	* alSourceStopv( ALsizei ns, ALuint *sids )
2464	*
2465	* If ns == 0, legal NOP.
2466	* If ns < 0, sets AL_INVALID_VALUE.
2467	*
2468	* If sids[0..ns-1] are all valid source names, then for each source with
2469	* state AL_PLAYING or AL_PAUSED change the state to AL_STOPPED. Otherwise,
2470	* set AL_INVALID_NAME.
2471	*/
2472	void alSourceStopv( ALsizei ns, const ALuint *sids ) {
2473	ALsizei i;
2474
2475	if( ns == 0 ) {
2476	/* legal NOP */
2477	return;
2478	}
2479
2480	if( ns < 0 ) {
2481	/* set error */
2482	_alcDCLockContext();
2483	_alDCSetError( AL_INVALID_VALUE );
2484	_alcDCUnlockContext();
2485
2486	return;
2487	}
2488
2489	SOURCELOCK();
2490
2491	/* validate */
2492	for( i = 0; i < ns; i++ ) {
2493	if( _alIsSource( sids[i] ) == AL_FALSE ) {
2494	_alDCSetError( AL_INVALID_NAME );
2495
2496	SOURCEUNLOCK();
2497
2498	return;
2499	}
2500	}
2501
2502	_alLockMixBuf();
2503
2504	for( i = 0; i < ns; i++ ) {
2505	_alRemoveSourceFromMixer( sids[i] );
2506	}
2507
2508	_alUnlockMixBuf();
2509
2510	SOURCEUNLOCK();
2511
2512	return;
2513	}
2514
2515	/*
2516	* alSourcePlayv( ALsizei ns, ALuint *sids )
2517	*
2518	* If ns == 0, legal NOP.
2519	* If ns < 0, sets AL_INVALID_VALUE.
2520	*
2521	* If sids[0..ns-1] are all valid source names, then for each source with
2522	* state AL_INITIAL, AL_STOPPED or AL_PAUSED, change the state to AL_PLAYING.
2523	* Otherwise, set AL_INVALID_NAME.
2524	*/
2525	void alSourcePlayv( ALsizei ns, const ALuint *sids ) {
2526	ALsizei i;
2527
2528	if( ns == 0 ) {
2529	/* legal NOP */
2530	return;
2531	}
2532
2533	if( ns < 0 ) {
2534	/* set error */
2535	_alcDCLockContext();
2536	_alDCSetError( AL_INVALID_VALUE );
2537	_alcDCUnlockContext();
2538
2539	return;
2540	}
2541
2542	SOURCELOCK();
2543
2544	/* validate */
2545	for( i = 0; i < ns; i++ ) {
2546	if( _alIsSource( sids[i] ) == AL_FALSE ) {
2547	_alDCSetError( AL_INVALID_NAME );
2548
2549	SOURCEUNLOCK();
2550
2551	return;
2552	}
2553	}
2554
2555	_alLockMixBuf();
2556
2557	for(i = 0; i < ns; i++) {
2558	_alAddSourceToMixer( sids[i] );
2559	}
2560
2561	_alUnlockMixBuf();
2562
2563	SOURCEUNLOCK();
2564
2565	return;
2566	}
2567
2568	/*
2569	* alSourcePausev( ALsizei ns, ALuint *sids )
2570	*
2571	* If ns == 0, legal NOP.
2572	* If ns < 0, sets AL_INVALID_VALUE.
2573	*
2574	* If sids[0..ns-1] are all valid source names, then for each source with
2575	* state AL_PLAYING, change the state to AL_PAUSED. Otherwise, set
2576	* AL_INVALID_NAME.
2577	*
2578	*/
2579	void alSourcePausev( ALsizei ns, const ALuint *sids ) {
2580	AL_source *src;
2581	ALsizei i;
2582
2583	if( ns == 0 ) {
2584	/* legal NOP */
2585	return;
2586	}
2587
2588	if( ns < 0 ) {
2589	/* set error */
2590	_alcDCLockContext();
2591	_alDCSetError( AL_INVALID_VALUE );
2592	_alcDCUnlockContext();
2593
2594	return;
2595	}
2596
2597	SOURCELOCK();
2598
2599	/* validate */
2600	for( i = 0; i < ns; i++ ) {
2601	if( _alIsSource( sids[i] ) == AL_FALSE ) {
2602	_alDCSetError( AL_INVALID_NAME );
2603
2604	SOURCEUNLOCK();
2605
2606	return;
2607	}
2608	}
2609
2610	/* set */
2611
2612	_alLockMixBuf();
2613
2614	for( i = 0; i < ns; i++ ) {
2615	src = _alDCGetSource( sids[i] );
2616
2617	/*
2618	* If source is active, set it to be paused. Otherwise,
2619	* it's a legal NOP.
2620	*/
2621
2622	if( src->state == AL_PLAYING ) {
2623	src->state = AL_PAUSED;
2624	}
2625	}
2626
2627	_alUnlockMixBuf();
2628
2629	SOURCEUNLOCK();
2630
2631	return;
2632	}
2633
2634	/*
2635	* _alCollapseSource( ALuint cid, ALuint sid,
2636	* ALuint nc, ALuint mixbuflen,
2637	* ALshort **buffers );
2638	*
2639	* Populates the scratch space associated with the source named by sid in the
2640	* context named by cid with interleaved data. The data is interleaved using
2641	* alternating channels from buffers[0..nc-1]. Each member of the set
2642	* buffers[0..nc-1] is an indepedent channel's worth of data, 0..mixbuflen/2
2643	* long bytes long.
2644	*
2645	* assumes locked context
2646	*/
2647	void _alCollapseSource( ALuint cid, ALuint sid,
2648	ALuint nc, ALuint mixbuflen,
2649	ALshort **buffers ) {
2650	ALboolean islooping;
2651	ALboolean isqueued;
2652	AL_source *src;
2653	AL_buffer *smp;
2654	ALuint len;
2655
2656	len = mixbuflen / nc;
2657
2658	src = _alGetSource( cid, sid );
2659	if(src == NULL) {
2660	_alSetError( cid, AL_INVALID_NAME );
2661	return;
2662	}
2663
2664	smp = _alGetBufferFromSid( cid, sid );
2665	if(smp == NULL) {
2666	_alSetError( cid, AL_INVALID_NAME );
2667	return;
2668	}
2669
2670	islooping = _alSourceIsLooping(src);
2671	isqueued = _alSourceGetPendingBids(src) > 0;
2672
2673	if(src->srcParams.outbuf == NULL) {
2674	src->srcParams.outbuf = malloc( mixbuflen );
2675
2676	if(src->srcParams.outbuf == NULL) {
2677	_alSetError( cid, AL_OUT_OF_MEMORY );
2678	return;
2679	}
2680	}
2681
2682	if(len > (smp->size - src->srcParams.soundpos)) {
2683	if( !isqueued && !islooping )
2684	{
2685	/* kludge. dc->silence? */
2686	memset(src->srcParams.outbuf, 0, mixbuflen);
2687
2688	/*
2689	* Non looping source get f_buffer truncated because
2690	* they don't (potentially) posses enough data.
2691	*/
2692	len = (smp->size - src->srcParams.soundpos);
2693	}
2694	}
2695
2696	_alChannelify(src->srcParams.outbuf, buffers, len, nc);
2697
2698	return;
2699	}
2700
2701	/*
2702	* _alInitSource( ALuint sid )
2703	*
2704	* Initialize an already allocated source.
2705	*/
2706	static void _alInitSource( ALuint sid ) {
2707	AL_source *src;
2708	AL_sourcestate *srcstate;
2709	int i;
2710
2711	src = _alDCGetSource( sid );
2712	if(src == NULL) {
2713	/* sid is invalid */
2714	return;
2715	}
2716
2717	/* set state */
2718	src->state = AL_INITIAL;
2719
2720	/* set identifier */
2721	src->sid = sid;
2722
2723	/* set data values */
2724	src->srcParams.outbuf = NULL;
2725	src->srcParams.soundpos = 0;
2726	src->srcParams.new_soundpos = -1;
2727	src->srcParams.new_readindex = -1;
2728	src->flags = ALS_NONE;
2729	src->reverbpos = 0;
2730
2731	for(i = 0; i < _ALC_MAX_CHANNELS; i++) {
2732	src->reverb_buf[i] = NULL;
2733	}
2734
2735	/* Initialize the buffer queue */
2736	_alSourceQueueInit( src );
2737
2738	srcstate = _alSourceQueueGetCurrentState( src );
2739	assert( srcstate );
2740
2741	_alSourceStateInit( srcstate );
2742
2743	/*
2744	* initialize position, direction, velocity.
2745	*/
2746	src->position.isset = AL_FALSE;
2747	_alSourceGetParamDefault( AL_POSITION, src->position.data );
2748
2749	src->direction.isset = AL_FALSE;
2750	_alSourceGetParamDefault( AL_DIRECTION, src->direction.data );
2751
2752	src->velocity.isset = AL_FALSE;
2753	_alSourceGetParamDefault( AL_VELOCITY, src->velocity.data );
2754
2755	/*
2756	* initialize reverb kludge
2757	*/
2758	src->reverb_scale = 0.25;
2759	src->reverb_delay = 0.00;
2760
2761	/*
2762	* initialize default mix rate
2763	*/
2764	src->mixrate = 1.0;
2765
2766	/*
2767	* initialize gain
2768	*/
2769	src->gain.isset = AL_FALSE;
2770	_alSourceGetParamDefault( AL_GAIN, &src->gain.data );
2771
2772	src->min_gain.isset = AL_FALSE;
2773	_alSourceGetParamDefault( AL_MIN_GAIN, &src->min_gain.data );
2774
2775	src->max_gain.isset = AL_FALSE;
2776	_alSourceGetParamDefault( AL_MAX_GAIN, &src->max_gain.data );
2777
2778	/* cone initializations */
2779	src->cone_inner_angle.isset = AL_FALSE;
2780	_alSourceGetParamDefault( AL_CONE_INNER_ANGLE,
2781	&src->cone_inner_angle.data );
2782
2783	src->cone_outer_angle.isset = AL_FALSE;
2784	_alSourceGetParamDefault( AL_CONE_OUTER_ANGLE,
2785	&src->cone_outer_angle.data );
2786
2787	src->cone_outer_gain.isset = AL_FALSE;
2788	_alSourceGetParamDefault( AL_CONE_OUTER_GAIN,
2789	&src->cone_outer_gain.data );
2790
2791	/*
2792	* initialize source relative, looping, pitch
2793	*/
2794
2795	src->relative.isset = AL_FALSE;
2796	_alSourceGetParamDefault( AL_SOURCE_RELATIVE, &src->relative.data );
2797
2798	src->looping.isset = AL_FALSE;
2799	_alSourceGetParamDefault( AL_LOOPING, &src->looping.data );
2800
2801	src->pitch.isset = AL_FALSE;
2802	_alSourceGetParamDefault( AL_PITCH, &src->pitch.data );
2803
2804	/*
2805	* initialize reference distance, max distance, rolloff factor
2806	*/
2807	src->reference_distance.isset = AL_FALSE;
2808	_alSourceGetParamDefault( AL_REFERENCE_DISTANCE,
2809	&src->reference_distance.data );
2810
2811	src->max_distance.isset = AL_FALSE;
2812	_alSourceGetParamDefault( AL_MAX_DISTANCE,
2813	&src->max_distance.data );
2814
2815	src->rolloff_factor.isset = AL_FALSE;
2816	_alSourceGetParamDefault( AL_ROLLOFF_FACTOR,
2817	&src->rolloff_factor.data );
2818
2819	return;
2820	}
2821
2822	/*
2823	* _alSourceTranslate( AL_source src, ALfloat delta )
2824	*
2825	* Translates the source (src) position attribute by delta. Delta is a three
2826	* tuple x/y/z.
2827	*
2828	* assumes locked context
2829	*/
2830	void _alSourceTranslate( AL_source src, ALfloat delta ) {
2831	ALfloat opos; / original source position */
2832
2833	opos = _alGetSourceParam( src, AL_POSITION );
2834	if( opos == NULL ) {
2835	/* no translation possible or needed */
2836	return;
2837	}
2838
2839	_alVectorTranslate( opos, opos, delta );
2840
2841	return;
2842	}
2843
2844	/*
2845	* srcParam functions
2846	*
2847	* The use of srcParam settings is this: most filter operations break down
2848	* into applying a multiplier or delay to the raw PCM data copied in
2849	* SplitSources. Since there operations are cumulative, this can be simplified
2850	* by simply collecting the coefficients of the operations and applying them
2851	* all at one. So instead of actually performing a gain or delay operation on
2852	* the PCM data, the filter can change the srcParam setting, which is applied
2853	* in _alSourceParamApply.
2854	*
2855	*/
2856
2857	/*
2858	* _alSourceParamReset( AL_source *src )
2859	*
2860	* Resets the srcParam settings gain and delay. Does not affect srcParam
2861	* settings associated with sound position or the temporary scratch space.
2862	*
2863	* assumes locked context
2864	*/
2865	void _alSourceParamReset( AL_source *src ) {
2866	AL_listener *lis;
2867	int i;
2868
2869	lis = _alcDCGetListener();
2870
2871	if(src == NULL) {
2872	return;
2873	}
2874
2875	for(i = 0; i < _ALC_MAX_CHANNELS; i++) {
2876	src->srcParams.delay[i] = 0;
2877	src->srcParams.gain[i] = 1.0;
2878	}
2879
2880	return;
2881	}
2882
2883	/*
2884	* _alSourceParamApply( AL_source *src,
2885	* ALuint nc, ALuint len, ALshort **buffers)
2886	*
2887	* Applies the srcParam settings of src to buffers[0..nc-1][0..(len/2)-1].
2888	*
2889	* This function should be called before a source is collapsed, in
2890	* ApplyFilters.
2891	*
2892	* assumes locked context
2893	*
2894	* FIXME: ignores delay
2895	*/
2896	void _alSourceParamApply( AL_source *src,
2897	ALuint nc, ALuint len, ALshort **buffers ) {
2898	ALuint sampLen;
2899	ALuint i;
2900	ALfloat gain;
2901
2902	sampLen = len / sizeof(ALshort); /* we pass sample length */
2903
2904	for(i = 0; i < nc; i++) {
2905	gain = src->srcParams.gain[i];
2906
2907	if(gain == 1.0) {
2908	/* don't floatmul when gain is 1.0 */
2909	continue;
2910	}
2911
2912	_alFloatMul( buffers[i], gain, sampLen );
2913	}
2914
2915	return;
2916	}
2917
2918	/*
2919	* _alSourceGetPendingBids( AL_source *src )
2920	*
2921	* Returns the number of buffers queued in the source, not including the
2922	* current one ( if any ).
2923	*/
2924	ALint _alSourceGetPendingBids(AL_source *src) {
2925	ALint retval = (src->bid_queue.size - 1) - src->bid_queue.read_index;
2926
2927	return retval;
2928	}
2929
2930	/*
2931	* _alSourceShouldIncrement( AL_source *src )
2932	*
2933	* Usually, the top-level mixing function _alMixSources handles updating each
2934	* source's sound position ( a pointer into its associate buffer's raw PCM
2935	* data. ) Some attributes, like pitch, demand a more sophisticated approach
2936	* that can only be done by the filter which handles this attribute.
2937	*
2938	* _alSourceShouldIncrement returns AL_TRUE if the top-level mixing function
2939	* should update this sort of state information, and AL_FALSE if it should
2940	* leave it to another portion of the library.
2941	*
2942	* assumes locked context
2943	*/
2944	ALboolean _alSourceShouldIncrement(AL_source *src) {
2945	AL_sourcestate *srcstate;
2946
2947	srcstate =_alSourceQueueGetCurrentState(src);
2948
2949	if((srcstate == NULL) \|\| (src->flags & ALS_NEEDPITCH)) {
2950	return AL_FALSE;
2951	}
2952
2953	return AL_TRUE;
2954	}
2955
2956	/*
2957	* _alSourceIncrement( AL_source *src, ALuint bytes )
2958	*
2959	* Increments the source's (src) offset into its current buffer's PCM data.
2960	*/
2961	void _alSourceIncrement(AL_source *src, ALuint bytes) {
2962	src->srcParams.soundpos += bytes;
2963
2964	return;
2965	}
2966
2967	/*
2968	* _alSourceGetBufptr( AL_source src, AL_buffer buf, ALuint index )
2969	*
2970	* Returns pointer to pcm data for buf, offset by src's soundpos.
2971	*
2972	* assumes locked context
2973	*/
2974	void _alSourceGetBufptr( AL_source src, AL_buffer *buf, ALuint ind ) {
2975	ALbyte *retval;
2976	ALuint pos = src->srcParams.soundpos;
2977
2978	retval = buf->orig_buffers[ind];
2979
2980	return retval + pos;
2981	}
2982
2983	/*
2984	* _alSourceBytesLeftByChannel( AL_source src, AL_buffer samp )
2985	*
2986	* Returns the byte length of the amount of data left before this source/samp
2987	* pair will either run out of data or be required to wrap. This returns the
2988	* byte length of a simple array, with 1 channel's worth of data.
2989	*/
2990	ALint _alSourceBytesLeft(AL_source src, AL_buffer samp) {
2991	ALuint nc = samp->num_buffers;
2992
2993	return nc * _alSourceBytesLeftByChannel(src, samp);
2994	}
2995
2996	/*
2997	* _alSourceBytesLeft(AL_source src, AL_buffer samp)
2998	*
2999	* Returns the byte length of the amount of data left before this source/samp
3000	* pair will either run out of data or be required to wrap. This returns the
3001	* byte length of an interleaved array, with periodic repetition equal to the
3002	* number of channels in the canonical format.
3003	*/
3004	ALint _alSourceBytesLeftByChannel(AL_source src, AL_buffer samp) {
3005	return samp->size - src->srcParams.soundpos;
3006	}
3007
3008	/*
3009	*
3010	* _alSourceIsQueue( AL_source * src )
3011	*
3012	* Returns AL_TRUE if source (src) has its queue set to AL_TRUE, AL_FALSE otherwise.
3013	*/
3014	ALboolean _alSourceIsQueue( AL_source * src ) {
3015
3016	if ( src->looping.isset == AL_TRUE &&
3017	src->looping.data == AL_TRUE &&
3018	src->bid_queue.size > 1 ) return AL_TRUE;
3019
3020	return AL_FALSE;
3021	}
3022
3023	/*
3024	* _alSourceIsLooping( AL_source *src )
3025	*
3026	* Returns AL_TRUE if the source (src) has its AL_LOOPING attribute set to
3027	* AL_TRUE, AL_FALSE otherwise.
3028	*/
3029	ALboolean _alSourceIsLooping( AL_source *src ) {
3030	ALboolean *boo = _alGetSourceParam( src, AL_LOOPING );
3031
3032	if( boo == NULL ) {
3033	return AL_FALSE;
3034	}
3035
3036	return *boo;
3037	}
3038
3039	/*
3040	* FL_alLockSource( UNUSED(const char *fn),
3041	* UNUSED(int ln),
3042	* ALuint cid,
3043	* ALuint sid )
3044	*
3045	* Locks source sid at cid.
3046	*/
3047	ALboolean FL_alLockSource( UNUSED(const char *fn),
3048	UNUSED(int ln),
3049	ALuint cid,
3050	ALuint sid ) {
3051	ALint sindex;
3052	AL_context *cc;
3053
3054	cc = _alcGetContext( cid );
3055	if( cc == NULL ) {
3056	return AL_FALSE;
3057	}
3058
3059	_alLockPrintf("_alLockSource", fn, ln);
3060
3061	sindex = spool_sid_to_index( &cc->source_pool, sid );
3062	if( sindex < 0 ) {
3063	/* invalid sid */
3064	return AL_FALSE;
3065	}
3066
3067	if( cc->source_pool.smutexen[sindex] == NULL ) {
3068	return AL_FALSE;
3069	}
3070
3071	_alLockMutex( cc->source_pool.smutexen[sindex] );
3072
3073	return AL_TRUE;
3074	}
3075
3076	/*
3077	* FL_alUnlockSource( UNUSED(const char *fn),
3078	* UNUSED(int ln),
3079	* ALuint cid,
3080	* ALuint sid )
3081	*
3082	* Unlocks source mutex for sid at cid.
3083	*/
3084	ALboolean FL_alUnlockSource( UNUSED(const char *fn),
3085	UNUSED(int ln),
3086	ALuint cid,
3087	ALuint sid ) {
3088	ALint sindex;
3089	AL_context *cc;
3090
3091	cc = _alcGetContext( cid );
3092	if( cc == NULL ) {
3093	return AL_FALSE;
3094	}
3095
3096	_alLockPrintf("_alUnlockSource", fn, ln);
3097
3098	sindex = spool_sid_to_index( &cc->source_pool, sid );
3099	if( sindex < 0 ) {
3100	/* invalid sid */
3101	return AL_FALSE;
3102	}
3103
3104	if( cc->source_pool.smutexen[sindex] == NULL ) {
3105	return AL_FALSE;
3106	}
3107
3108	_alUnlockMutex( cc->source_pool.smutexen[sindex] );
3109
3110	return AL_TRUE;
3111	}
3112
3113	/*
3114	* _alGetSourceParam( AL_source *source, ALenum param )
3115	*
3116	* Returns a pointer to the source attribute specified by param. If the
3117	* attribute has not been set by the application, NULL is returned.
3118	*
3119	* NOTES:
3120	* This returns NULL if the paramater specified by param hasn't
3121	* been set, so that the calling function can determine what it
3122	* thinks a sensible default should be. Perhaps it would be
3123	* best to have a set of default variables here and return their
3124	* value when need be?
3125	*/
3126	void _alGetSourceParam(AL_source source, ALenum param )
3127	{
3128	if( _alSourceIsParamSet( source, param ) == AL_FALSE )
3129	{
3130	if(param == AL_BUFFER)
3131	assert(0);
3132
3133	return NULL;
3134	}
3135
3136	switch( param )
3137	{
3138	case AL_BUFFER:
3139	if( source->bid_queue.read_index >=
3140	source->bid_queue.size )
3141	{
3142	int size = source->bid_queue.size;
3143
3144	/* often the case for size one queues */
3145	return &source->bid_queue.queue[size - 1];
3146	}
3147	else
3148	if( source->bid_queue.size > 0 )
3149	{
3150	int rind = source->bid_queue.read_index;
3151
3152	assert(rind < source->bid_queue.size);
3153	return &source->bid_queue.queue[rind];
3154	}
3155	else
3156	{
3157	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
3158	"_alGetSourceState: bid_queue.size == %d",
3159	source->bid_queue.size);
3160	}
3161	break;
3162	case AL_CONE_INNER_ANGLE:
3163	return &source->cone_inner_angle.data;
3164	break;
3165	case AL_CONE_OUTER_ANGLE:
3166	return &source->cone_outer_angle.data;
3167	break;
3168	case AL_CONE_OUTER_GAIN:
3169	return &source->cone_outer_gain.data;
3170	break;
3171	case AL_DIRECTION:
3172	return &source->direction.data;
3173	break;
3174	case AL_GAIN:
3175	case AL_GAIN_LINEAR_LOKI:
3176	return &source->gain.data;
3177	break;
3178	case AL_LOOPING:
3179	return &source->looping.data;
3180	break;
3181	case AL_PITCH:
3182	return &source->pitch.data;
3183	break;
3184	case AL_POSITION:
3185	return &source->position.data;
3186	break;
3187	case AL_SOURCE_RELATIVE:
3188	return &source->relative.data;
3189	break;
3190	case AL_VELOCITY:
3191	return &source->velocity.data;
3192	break;
3193	case AL_MIN_GAIN:
3194	return &source->min_gain.data;
3195	break;
3196	case AL_MAX_GAIN:
3197	return &source->max_gain.data;
3198	break;
3199	case AL_SOURCE_STATE:
3200	return &source->state;
3201	break;
3202	case AL_REFERENCE_DISTANCE:
3203	return &source->reference_distance.data;
3204	break;
3205	case AL_MAX_DISTANCE:
3206	return &source->max_distance.data;
3207	break;
3208	case AL_ROLLOFF_FACTOR:
3209	return &source->rolloff_factor.data;
3210	break;
3211	default:
3212	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
3213	"unknown source param 0x%x", param);
3214
3215	assert( 0 );
3216
3217	break;
3218	}
3219
3220	if(param == AL_BUFFER)
3221	assert(0);
3222	return NULL;
3223	}
3224
3225	/*
3226	* _alSourceIsParamSet( AL_source *source, ALenum param )
3227	*
3228	* Returns AL_TRUE if param is set for source, AL_FALSE otherwise.
3229	*/
3230	ALboolean _alSourceIsParamSet( AL_source *source, ALenum param ) {
3231	switch( param ) {
3232	case AL_BUFFER:
3233	case AL_SOURCE_STATE:
3234	return AL_TRUE;
3235	case AL_CONE_INNER_ANGLE:
3236	return source->cone_inner_angle.isset;
3237	case AL_CONE_OUTER_ANGLE:
3238	return source->cone_outer_angle.isset;
3239	case AL_CONE_OUTER_GAIN:
3240	return source->cone_outer_gain.isset;
3241	case AL_DIRECTION:
3242	return source->direction.isset;
3243	case AL_GAIN:
3244	case AL_GAIN_LINEAR_LOKI:
3245	return source->gain.isset;
3246	case AL_LOOPING:
3247	return source->looping.isset;
3248	case AL_PITCH:
3249	return source->pitch.isset;
3250	case AL_POSITION:
3251	return source->position.isset;
3252	case AL_SOURCE_RELATIVE:
3253	return source->relative.isset;
3254	case AL_VELOCITY:
3255	return source->velocity.isset;
3256	case AL_MIN_GAIN:
3257	return source->min_gain.isset;
3258	case AL_MAX_GAIN:
3259	return source->max_gain.isset;
3260	case AL_REFERENCE_DISTANCE:
3261	return source->reference_distance.isset;
3262	case AL_MAX_DISTANCE:
3263	return source->max_distance.isset;
3264	case AL_ROLLOFF_FACTOR:
3265	return source->rolloff_factor.isset;
3266	default:
3267	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
3268	"unknown source param 0x%x", param);
3269	return AL_FALSE;
3270	}
3271	}
3272
3273	/*
3274	* _alSourceGetParamDefault( ALenum param, ALvoid *retref )
3275	*
3276	* Sets retref to the default value for param.
3277	*/
3278	void _alSourceGetParamDefault( ALenum param, ALvoid *retref ) {
3279	ALint *ip = retref;
3280	ALboolean *bp = retref;
3281	ALfloat *fp = retref;
3282	Rcvar pref = NULL;
3283
3284	switch( param ) {
3285	case AL_BUFFER:
3286	*ip = 0;
3287	break;
3288	case AL_CONE_INNER_ANGLE:
3289	case AL_CONE_OUTER_ANGLE:
3290	*fp = 360.0f;
3291	break;
3292	case AL_MIN_GAIN:
3293	case AL_CONE_OUTER_GAIN:
3294	*fp = 0.0f;
3295	break;
3296	case AL_GAIN:
3297	case AL_GAIN_LINEAR_LOKI:
3298	case AL_MAX_GAIN:
3299	case AL_PITCH:
3300	case AL_REFERENCE_DISTANCE:
3301	*fp = 1.0f;
3302	break;
3303	case AL_ROLLOFF_FACTOR:
3304	/*
3305	* check user preference. If set, use that.
3306	* Otherwise, use the default of 1.0f
3307	*/
3308	pref = rc_lookup( "source-rolloff-factor" );
3309	if( pref != NULL ) {
3310	*fp = rc_tofloat( pref );
3311	} else {
3312	*fp = 1.0f;
3313	}
3314	break;
3315	case AL_DIRECTION:
3316	case AL_POSITION:
3317	case AL_VELOCITY:
3318	fp[0] = 0.0f;
3319	fp[1] = 0.0f;
3320	fp[2] = 0.0f;
3321	break;
3322	case AL_LOOPING:
3323	case AL_SOURCE_RELATIVE:
3324	*bp = AL_FALSE;
3325	break;
3326	case AL_MAX_DISTANCE:
3327	*fp = FLT_MAX;
3328	break;
3329	case AL_SOURCE_STATE:
3330	default:
3331	assert( 0 );
3332	break;
3333	}
3334	}
3335
3336	/*
3337	* _alSourceGetNextBuffer( AL_source *src )
3338	*
3339	* Returns the next buffer in a queue, or NULL if no next buffer exists.
3340	* Assumes locked source.
3341	*
3342	*/
3343	AL_buffer _alSourceGetNextBuffer( AL_source src )
3344	{
3345	assert( src );
3346
3347	if(src->bid_queue.read_index < src->bid_queue.size - 1)
3348	{
3349	ALuint ri = src->bid_queue.read_index;
3350	ALuint bid = src->bid_queue.queue[ri];
3351
3352	return _alGetBuffer(bid);
3353	}
3354
3355	return NULL;
3356	}
3357
3358	/*
3359	* _alSourceQueuedBuffers( AL_source *src )
3360	*
3361	* Returns the total number of buffers queued for the source,
3362	* without regard to the read or write pointer.
3363	*/
3364	ALint _alSourceQueuedBuffers( AL_source *src )
3365	{
3366	assert( src );
3367
3368	return src->bid_queue.size;
3369	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: