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

/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
 * vi:set ts=8:
 *
 * al_filter.c
 *
 * Contains filters.
 *
 *
 * Short guide to filters:
 *
 * Filters all have the prefix alf_<something>.  Each filter
 * defined in software_time_filters or software_frequency_filters
 * is applied to each source that finds its way into the mixer.
 *
 * ApplyFilters takes a chunk of data from the original buffer
 * associated with the passed source.
 *
 * This chunk is understood to be that block of data samp->_orig_buffer
 * offset src->soundpos to src->soundpos + bufsiz, where src is the
 * passed AL_source, samp is the AL_buffer associated with src, and
 * bufsiz is the length of the chunk of data that we want.  It is usually
 * set to _AL_DEF_BUFSIZE, unless specified by ALC_BUFFERSIZE in the
 * application.
 *
 * Applying filters to a source does not (should not) change the original
 * pcm data.  ApplyFilters will split the original pcm data prior to
 * calling each filter, and filters should restrict themselves to
 * manipulating the passed data.
 *
 * time domain filters (those defines in software_time_filters) are
 * passed:
 *      ALuint cid
 *              identifier for the context that this source belongs to
 *      AL_source *src
 *              source that the filter should be applied to
 *      AL_buffer *samp
 *              buffer that the source is associated with
 *      ALshort **buffers
 *              arrays of points to PCM data, one element per
 *              channel(left/right/etc)
 *      ALuint nc
 *              number of elements in buffers
 *      ALuint len
 *              byte length of each element in buffers
 *
 * Filters are expected to alter buffers[0..nc-1] in place.  After
 * the ApplyFilter iteration is over, the resulting data is mixed into
 * the main mix buffer and forgotten.  The data altered is cumulative,
 * that is to say, if two filters alf_f and alf_g occur in sequential
 * order, alf_g will see the pcm data after alf_f has altered it.
 *
 * FINER POINTS:
 *
 * A lot of the filters make effects by modulating amplitude and delay.
 * Because these changes are cumulative, we can reduce the application
 * of amplitude and delay changes to one operation.  This is the point
 * of SourceParamApply --- filters can make changes to srcParams.gain
 * and srcParams.delay in a source and have those changes applied at
 * the end of the ApplyFilters call for the source.  These values are
 * reset to their defaults at the top of the ApplyFilters call.
 *
 */
#include "al_siteconfig.h"

#include <AL/alext.h>

#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>

#include "al_buffer.h"
#include "al_debug.h"
#include "al_error.h"
#include "al_filter.h"
#include "al_listen.h"
#include "al_main.h"
#include "al_mixer.h"
#include "al_source.h"
#include "al_queue.h"
#include "al_vector.h"

#include "alc/alc_context.h"
#include "alc/alc_speaker.h"

#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define MAX(a,b) (((a) < (b)) ? (b) : (a))

#define MIN_PITCH 0.25f

#define USE_TPITCH_LOOKUP 1 /* icculus change here JIV FIXME */

/*
 * _AL_CUTTOFF_ATTENUATION is the value below which, sounds are not further
 * distance attenuated.  The purpose of this culling is to avoid pop-off
 * artifacts.
 *
 * Elias: This has been found to cause insufficient distance attenuation
 * and has therefore been effectively disabled by setting it to 0. If no
 * problems show up, the value should be completely removed.
 * The original was value 0.01
 */
#define _AL_CUTTOFF_ATTENUATION 0.00

/*
 * TPITCH_MAX sets the number of discrete values for AL_PITCH we can have.
 * You can set AL_PITCH to anything, but integer rounding will ensure that
 * it will fall beween MIN_SCALE and 2.0.
 *
 * 2.0 is an arbitrary constant, and likely to be changed.
 */
#define TPITCH_MAX       256

/*
 * The default software time domain filters.
 *
 * I wish I could say that the order of these does not matter,
 * but it does.  Namely, tdoppler and tpitch must occur in that
 * order, and they must occur before any other filter.  listenergain must
 * occur last.
 */
static time_filter_set software_time_filters[] = {
        { "tdoppler",      alf_tdoppler }, /* time-domain doppler filter */
        { "tpitch",        alf_tpitch   }, /* time-domain pitch filter */
        { "da",            alf_da },
        { "reverb",        alf_reverb },
        { "coning",        alf_coning },
        { "panning",       alf_panning },
        { "minmax",        alf_minmax },
        { "listenergain",  alf_listenergain },
        { { 0 },     NULL }
};

/*
 * compute_sa( ALfloat *source_pos, ALfloat source_max,
 *             ALfloat source_ref, ALfloat source_gain,
 *             ALfloat source_rolloff,
 *             ALfloat *speaker_pos,
 *             ALfloat (*df)( ALfloat dist, ALfloat rolloff,
 *                            ALfloat ref, ALfloat max))
 *
 * computes distance attenuation with respect to a speaker position.
 *
 * This is some normalized value which gets expotenially closer to 1.0
 * as the source approaches the listener.  The minimum attenuation is
 * AL_CUTTOFF_ATTENUATION, which approached when the source approaches
 * the max distance.
 *
 * source_pos = source position   [x/y/z]
 * source_max = source specific max distance
 * speaker_pos = speaker position [x/y/z]
 * ref        = source's reference distance
 * df         = distance model function
 * max        = maximum distance, beyond which everything is clamped at
 *              some small value near, but not equal to, zero.
 */
static ALfloat compute_sa( ALfloat *source_pos, ALfloat source_max,
                           ALfloat source_ref, ALfloat source_gain,
                           ALfloat source_rolloff,
                           ALfloat *speaker_pos,
                           ALfloat df( ALfloat dist, ALfloat rolloff, ALfloat ref, ALfloat max ));

#if USE_TPITCH_LOOKUP
/*
 * our quick lookup table for our time domain pitch filter.
 *
 *
 * We initialize each element in offsets to be a set of offsets,
 * such that
 *
 *      offset[x][y]     = int portion of y * pitch
 *      fractinoal[x][y] = fractional portion of y * pitch
 *
 *      Where x is the discrete integer value of pitch, and y is
 *      any value between 0 and the length of a buffer.
 *
 * What's the point?  To save the pain of float->int conversion at
 * runtime, which is needed to map the original PCM data to a
 * "pitch modified" mapping of the same data.
 *
 */
static struct {
        int *offsets[TPITCH_MAX]; /* use int instead of ALint because
                                   * these are array indexes
                                   */
        float *fractionals[TPITCH_MAX];
        ALuint max;
        ALuint middle; /* the index which pitch == 1.0 corresponds to */
        ALuint len; /* length of offsets[0...TPITCH_MAX] in samples */
} tpitch_lookup = { { NULL }, { NULL }, 0, 0, 0 };

/* func associated with our tpitch lookup */
static void init_tpitch_lookup(ALuint len);
#endif

static ALfloat compute_doppler_pitch(ALfloat *object1, ALfloat *o1_vel,
                               ALfloat *object2, ALfloat *o2_vel,
                               ALfloat factor, ALfloat speed);

/*
 * _alInitTimeFilters( time_filter_set *tf_ptr_ref )
 *
 * Initializes tf_ptr_ref to the current set of time filters, and initialize
 * tpitch_lookup_max if it hasn't been initialized before.
 */
void _alInitTimeFilters( time_filter_set *tf_ptr_ref ) {
        ALuint i = 0;

        do {
                tf_ptr_ref[i] = software_time_filters[i];
        } while(software_time_filters[i++].filter != NULL);

#if USE_TPITCH_LOOKUP
        /*
         * init tpitch_loopup only if it hasn't been initialized
         * yet.
         */
        if(tpitch_lookup.max != TPITCH_MAX) {
                tpitch_lookup.max    = TPITCH_MAX;
                tpitch_lookup.middle = TPITCH_MAX / 2;

                for(i = 0; i < tpitch_lookup.max; i++)
                {
                        free(tpitch_lookup.offsets[i]);
                        free(tpitch_lookup.fractionals[i]);
                        tpitch_lookup.offsets[i] = 0;
                        tpitch_lookup.fractionals[i] = 0;
                }
        }
#endif

        return;
}

/*
 * _alDestroyFilters( void )
 *
 * Deallocates data structures used by the filters and helper functions.
 */
void _alDestroyFilters( void ) {
#if USE_TPITCH_LOOKUP
        ALuint i;

        for(i = 0; i < TPITCH_MAX; i++)
        {
                free(tpitch_lookup.offsets[i]);
                free(tpitch_lookup.fractionals[i]);

                tpitch_lookup.offsets[i] = 0;
                tpitch_lookup.fractionals[i] = 0;
        }
        tpitch_lookup.len = 0;
#endif

        return;
}

/*
 * _alApplyFilters( ALuint cid, ALuint sid )
 *
 * _alApplyFilters is called from the mixing function, and is passed
 * a source id and the context where this sourceid has meaning.
 *
 * The filters that are applied to the source are determined by the
 * context.  Each context is initialized such that it contains a table
 * of the software filters.  Extensions and plugins can be later loaded
 * to override the default functionality.  The point being, each context's
 * filter "signature" may be different.
 *
 * assumes locked source sid
 */
void _alApplyFilters( ALuint cid, ALuint sid ) {
        AL_source *src;
        AL_buffer *samp;
        time_filter_set *cc_tfilters;
        time_filter *tf;
        ALuint mixbuflen; /* byte size of total data to compose (all channels) */
        ALint len;        /* byte size of one channel's worth of data to compose */
        ALint filterlen;  /* filterlen is adjusted below to take into account looping, etc */
        int ic;           /* internal (canon) chans   */
        int mc;           /* mixer chans (==speakers) */
        ALboolean *boolp;       /* for determining bool flags */
        int i;

        /* initialize */
        ic = _alGetChannelsFromFormat( _ALC_CANON_FMT );

        _alcLockContext( cid );

        mc = _alcGetNumSpeakers( cid );
        mixbuflen = _alcGetWriteBufsiz( cid );

        samp = _alGetBufferFromSid( cid, sid );
        if(samp == NULL) {
                _alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
                        "_alFilter: null samp, sid == %d", sid);

                _alcUnlockContext( cid );
                return;
        }

        _alcUnlockContext( cid );

        len = mixbuflen * ((float) ic / mc);
        filterlen = len;

        /*
         * Allocate scratch space to hold enough data for the source
         * about to be split.  We allocate more space in case of a
         * multichannel source.
         */
        if(f_buffers.len < len / sizeof (ALshort))
        {
                void *temp;
                ALuint newlen = len * _alGetChannelsFromFormat(samp->format);

                for(i = 0; i < mc; i++)
                {
                        temp = realloc(f_buffers.data[i], newlen);
                        if(temp == NULL) {
                                /* FIXME: do something */
                        }

                        f_buffers.data[i] = temp;
                }

                f_buffers.len = newlen;
        }

#if USE_TPITCH_LOOKUP
        if(tpitch_lookup.len < (ALuint) len)
        {
                init_tpitch_lookup(len);
        }
#endif

        src  = _alGetSource(cid, sid);
        if(src == NULL) {
                _alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
                        "_alFilter: null src, sid == %d", sid);
                return;
        }

        /* streaming buffer?  set soundpos */
        if(samp->flags & ALB_STREAMING) {
                src->srcParams.soundpos = samp->streampos;

                if(samp->streampos > samp->size) {
                        memset(src->srcParams.outbuf, 0, len);

#ifdef DEBUG_MAXIMUS
                        fprintf(stderr, "underflow!!!!!!!!!!!!!!!!\n");
#endif
                        return; /* underflow */
                }
        }

        _alSourceParamReset(src); /* reset srcParam settings */

        _alSplitSources(cid, sid, mc, len, samp, (ALshort **) f_buffers.data);

        /*
         * translate head relative sources
         */
        boolp = _alGetSourceParam(src, AL_SOURCE_RELATIVE);

        if(boolp != NULL) {
                _alDebug(ALD_SOURCE, __FILE__, __LINE__,
                "_alApplyFilters: sid %d relative boolp = %d", sid, *boolp );

                if(*boolp == AL_TRUE) {
                        /* This is a RELATIVE source, which means we must
                         * translate it before applying any sort of positional
                         * filter to it.
                         */
                        AL_context *cc;

                        _alcLockContext( cid );

                        cc = _alcGetContext(cid);
                        if(cc != NULL) {
                                _alSourceTranslate(src, cc->listener.position );
                        }

                        _alcUnlockContext( cid );
                }
        }

        /*
         * adjust len to account for end of sample, looping, etc
         */
        if(filterlen > _alSourceBytesLeft(src, samp))
        {
                /* John Quigley's patch, check it out -- jiv */
               if((_alSourceIsLooping( src ) == AL_FALSE)
                        && (src->srcParams.new_readindex == -1))
                {
                        /* Non looping source */
                        filterlen = _alSourceBytesLeft(src, samp);
                }
        }

        if(filterlen > 0)
        {
                cc_tfilters = _alcGetTimeFilters(cid);

                /* apply time domain filters */
                for(i = 0; cc_tfilters[i].filter != NULL; i++)
                {
                        tf = cc_tfilters[i].filter;

                        tf(cid, src, samp, (ALshort **) f_buffers.data,
                           mc, filterlen);
                }

                /*
                 *  Apply gain and delay for filters that don't actually touch
                 *  the data ( alf_da).
                 */
                _alSourceParamApply(src, mc, filterlen,
                                    (ALshort **) f_buffers.data);
        }


        /*
         * Take the resulting pcm data in f_buffers, and mix these into
         * the source's temporary output buffer.
         */
        _alCollapseSource(cid, sid, mc, mixbuflen, (ALshort **) f_buffers.data);

        /*
         * head RELATIVE sources need to be untranslated, lest their
         * position become weird.
         */
        if((boolp != NULL) && (*boolp == AL_TRUE)) {
                AL_context *cc;
                ALfloat ipos[3]; /* inverse listener position */

                _alcLockContext( cid );

                cc = _alcGetContext(cid);

                if(cc != NULL) {
                        _alVectorInverse(ipos, cc->listener.position);
                        _alSourceTranslate(src, ipos);
                }

                _alcUnlockContext( cid );
        }

        return;
}

/*
 * alf_coning
 *
 * Implements the coning filter, which is used when CONE_INNER_ANGLE
 * or CONE_OUTER_ANGLE is set.  This is used for directional sounds.
 *
 * The spec is vague as to the actual requirements of directional sounds,
 * and Carlo has suggested that we maintain the DirectSound meaning for
 * directional sounds, namely (in my interpretation):
 *
 *    The inner, outer cone define three zones: inside inner cone
 *    (INSIDE), between inner and outer cone (BETWEEN, outside outer cone,
 *    (OUTSIDE).
 *
 *    In INSIDE, the gain of the sound is attenuated as a normal
 *    positional source.
 *
 *    In OUTSIDE, the gain is set to some value specified by the user.
 *
 *    In BETWEEN, the gain is transitionally set to some value between
 *    what it would be in INSIDE and OUTSIDE.
 *
 * This requires an additional source paramter, like CONE_OUTSIDE_ATTENUATION,
 * and quite frankly seems goofy.  This implementation implements the
 * following convention:
 *
 *    In INSIDE, the gain of the sound is attenuated as a normal
 *    positional source.
 *
 *    In OUTSIDE, the gain is set to _AL_CUTTOFF_ATTENUATION
 *
 *    In BETWEEN, the gain is transitionally set to some value between
 *    what it would be in INSIDE and OUTSIDE.
 *
 * Well, okay that's still pretty goofy.  Folks who want to set a
 * minimum attenuation can stil do so using AL_SOURCE_ATTENUATION_MIN.
 *
 * IMPLEMENTATION:
 * okay, we check the angle between the speaker position and
 * the source's direction vector, using the source's position
 * as the origin.  This angle we call theta.
 *
 * Then, we compare theta with the outer cone angle.  If it's greater,
 * we use the min attenuation.  If it's less, we compare theta with
 * the inner cone angle.  If it's greater, we attenuate as normal.
 * Otherwise, we don't attenuate at all (full volume, pitch etc).
 *
 * assumes locked source
 *
 * FIXME: please check my math.
 *        - with an AL_NONE distance model, should this do anything
 *          at all?
 */
void alf_coning( ALuint cid,
                 AL_source *src,
                 UNUSED(AL_buffer *samp),
                 UNUSED(ALshort **buffers),
                 ALuint nc,
                 UNUSED(ALuint len)) {
        AL_context *cc;
        ALfloat sa;  /* speaker attenuation */
        ALfloat *sp; /* source position  */
        ALfloat *sd; /* source direction */
        ALfloat lp[3]; /* listener position */
        ALfloat theta; /* angle between listener and source's direction
                        * vector, with the source's position as origin.
                        */
        ALfloat srcDir[3];
        ALfloat icone;      /* inner cone angle. */
        ALfloat ocone;      /* outer cone angle.  */
        ALfloat (*df)( ALfloat dist, ALfloat rolloff, ALfloat ref, ALfloat max ); /* distance model func */
        ALfloat smax;       /* source specific max distance */
        ALfloat ref;        /* source specific reference distance */
        ALfloat gain;       /* source specific gain */
        ALfloat outergain;  /* source specific outer gain */
        ALfloat rolloff;    /* source specific rolloff factor */
        void *temp;
        ALuint i;

        _alcLockContext( cid );
        cc = _alcGetContext( cid );
        if(cc == NULL) {
                /* ugh.  bad context id */

                _alcUnlockContext( cid );
                return;
        }

        /*
         * The source specific max is set to max at this point, but may be
         * altered below of the application has set it.
         */
        smax = FLT_MAX;
        df = cc->distance_func;

        _alcUnlockContext( cid );

        alGetListenerfv(AL_POSITION, lp);

        /* If no direction set, return */
        sd = _alGetSourceParam( src, AL_DIRECTION );
        if(sd == NULL) {
                /*
                 * source has no direction (normal).  leave it for alf_da
                 */
                return;
        }

        sp = _alGetSourceParam( src, AL_POSITION );
        if(sp == NULL) {
                /* If no position set, return */

                return;
        }

        /* get source specific ref distance */
        temp = _alGetSourceParam( src, AL_REFERENCE_DISTANCE );
        if( temp != NULL ) {
                ref = * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_REFERENCE_DISTANCE, &ref );
        }

        /* get source specific gain */
        temp = _alGetSourceParam( src, AL_GAIN );
        if( temp != NULL ) {
                gain =  * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_GAIN, &gain );
        }

        /* get source specific max distance */
        temp = _alGetSourceParam( src, AL_MAX_DISTANCE );
        if( temp != NULL ) {
                smax =  * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_MAX_DISTANCE, &smax );
        }

        /* get source specific rolloff factor */
        temp = _alGetSourceParam( src, AL_ROLLOFF_FACTOR );
        if( temp != NULL ) {
                rolloff =  * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_ROLLOFF_FACTOR, &rolloff );
        }

        srcDir[0] = sp[0] + sd[0];
        srcDir[1] = sp[1] + sd[1];
        srcDir[2] = sp[2] + sd[2];

        /*
         * Get CONE settings.
         *
         * If unset, use 360.0 degrees
         */
        temp = _alGetSourceParam( src, AL_CONE_INNER_ANGLE );
        if(temp != NULL) {
                icone = _alDegreeToRadian(* (ALfloat *) temp);
        } else {
                _alSourceGetParamDefault( AL_CONE_INNER_ANGLE, &icone );
        }

        temp = _alGetSourceParam( src, AL_CONE_OUTER_ANGLE );
        if(temp != NULL) {
                ocone = _alDegreeToRadian(* (ALfloat *) temp);
        } else {
                _alSourceGetParamDefault( AL_CONE_OUTER_ANGLE, &ocone );
        }

        temp = _alGetSourceParam( src, AL_CONE_OUTER_GAIN );
        if(temp != NULL) {
                outergain = * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_CONE_OUTER_GAIN, &outergain );
        }

        _alDebug(ALD_SOURCE, __FILE__, __LINE__,
                "alf_coning: sid %d icone %f ocone %f", src->sid, icone, ocone );

        theta = _alVectorAngleBetween(sp, lp, srcDir);

        if( theta <= (icone / 2.0f) ) {
                /*
                 * INSIDE:
                 *
                 * attenuate normally
                 */
                _alDebug(ALD_SOURCE, __FILE__, __LINE__,
                        "alf_coning: sid %d theta %f INSIDE",
                        src->sid, theta );

                /*
                 * speaker[i] is in inner cone, don't do
                 * anything.
                 */
                sa = compute_sa( sp, smax, ref, gain, rolloff, lp, df );
        } else if( theta <= ( ocone / 2.0f) ) {
                /*
                 * BETWEEN:
                 *
                 * kind of cheesy, but we average the INSIDE
                 * and OUTSIDE attenuation.
                 */
                _alDebug(ALD_SOURCE, __FILE__, __LINE__,
                        "alf_coning: sid %d theta %f BETWEEN",
                        src->sid, theta);

                sa = compute_sa( sp, smax, ref, gain, rolloff, lp, df );

                sa += _AL_CUTTOFF_ATTENUATION;
                sa /= 2;
        } else {
                /*
                 * OUTSIDE:
                 *
                 * Set to attenuation_min
                 */
                _alDebug(ALD_SOURCE, __FILE__, __LINE__,
                        "alf_coning: sid %d theta %f OUTSIDE",
                        src->sid, theta );

                if( outergain < _AL_CUTTOFF_ATTENUATION ) {
                        sa = _AL_CUTTOFF_ATTENUATION;
                } else {
                        sa = outergain;
                }
        }

        for(i = 0; i < nc; i++) {
                /* set gain, to be applied in SourceParamApply */
                src->srcParams.gain[i] *= sa;
        }

        return;
}

/*
 * alf_reverb
 *
 * As far as reverb implementations go, this sucks.  Should be
 * frequency based?
 *
 * Should be able to be applied in sequence for second order
 * approximations.
 *
 * FIXME: this is so ugly!  And consumes a ton of memory.
 */
void alf_reverb( UNUSED(ALuint cid),
                 AL_source *src,
                 AL_buffer *samp,
                 ALshort **buffers,
                 ALuint nc,
                 ALuint len ) {
        ALshort *bpt; /* pointer to passed buffers */
        ALshort *rpt; /* pointer to reverb buffers */
        ALuint i;
        ALfloat scale = src->reverb_scale;
        ALuint delay  = src->reverb_delay;
        ALuint k;
        int sample;

        /* with a delay of 0.0, no reverb possible or needed */
        if(!(src->flags & ALS_REVERB)) {
                return;
        }

        /*
         * initialize persistent reverb buffers if they haven't been
         * done before
         */
        for(i = 0; i < nc; i++) {
                if(src->reverb_buf[i] == NULL) {
                        src->reverb_buf[i] = malloc(samp->size);
                        memset(src->reverb_buf[i], 0, samp->size);
                }
        }

        if(src->srcParams.soundpos > delay) {
                int revoffset = ((src->srcParams.soundpos - delay) / sizeof(ALshort));

                for(i = 0; i < nc; i++) {
                        bpt  = buffers[i];
                        rpt  = src->reverb_buf[i];
                        rpt += revoffset;

                        for(k = 0; k < len / sizeof(ALshort); k++) {
                                sample = bpt[k] + rpt[k] * scale;

                                if(sample > canon_max) {
                                        sample = canon_max;
                                } else if (sample < canon_min) {
                                        sample = canon_min;
                                }

                                bpt[k] = sample;
                        }
                }
        }

        _alBuffersAppend(src->reverb_buf,
                        (void **) buffers, len, src->reverbpos, nc);

        src->reverbpos += len;

        return;
}

/*
 * alf_da
 *
 * alf_da implements distance attenuation.  We call compute_sa to get the
 * per-speaker attenuation for each channel, and manipulate the srcParam gain
 * settings to effect that computation.
 *
 * alf_da returns early if we discover that the source has
 * either CONE_INNER_ANGLE or CONE_OUTER_ANGLE set (ie, is a
 * directional source).  In those cases, alf_coning should do
 * the distance attenuation.
 *
 * assumes locked source
 *
 * FIXME:
 *    Remind me to clean this up.
 */
void alf_da( ALuint cid,
             AL_source *src,
             UNUSED(AL_buffer *samp),
             UNUSED(ALshort **buffers),
             ALuint nc,
             UNUSED(ALuint len)) {
        AL_context *cc;
        ALfloat *sp; /* source position */
        ALfloat sa;  /* speaker attenuation */
        ALfloat listener_position[3];
        ALfloat *temp;
        ALuint i;
        ALfloat (*df)( ALfloat dist, ALfloat rolloff, ALfloat ref, ALfloat max ); /* distance model func */
        ALfloat gain; /* source specific gain */
        ALfloat ref;  /* source specific ref distance */
        ALfloat smax;        /* source specific max distance */
        ALfloat rolloff; /* source specific rolloff factor */

        /* get distance scale */
        _alcLockContext( cid );
        cc = _alcGetContext(cid);
        if(cc == NULL) {
                _alcUnlockContext( cid );

                /* ugh.  bad context id */
                return;
        }

        df = cc->distance_func;

        _alcUnlockContext( cid );

        /*
         *
         * The source specific max is set to max at this point, but may be
         * altered below of the application has set it.
         */
        smax = FLT_MAX;

        /*
         * if coning is enabled for this source, then we want to
         * let the coning filter take care of attenuating since
         * it has more information then we do.
         *
         * We check the direction flag because coning may not
         * be set (ie, they use defaults)
         */
        temp = _alGetSourceParam(src, AL_DIRECTION);
        if(temp != NULL) {
                /*
                 * This sound has it's direction set, so leave it
                 * to the coning filter.
                 */
                _alDebug( ALD_SOURCE, __FILE__, __LINE__,
                        "Directional sound, probably not right" );

                return;
        }

        /* ambient near listener */
        alGetListenerfv(AL_POSITION, listener_position);

        sp = _alGetSourceParam( src, AL_POSITION );
        if(sp == NULL) {
                /*
                 * As an optimization, don't do any attenuation if
                 * the source is relative and there's no position.
                 */
                ALboolean *isrel;

                isrel = _alGetSourceParam( src, AL_SOURCE_RELATIVE );
                if ( isrel && *isrel ) {
                        ALfloat *gp = _alGetSourceParam(src, AL_GAIN);

                        if(gp)
                        {
                                for(i = 0; i < _ALC_MAX_CHANNELS; i++)
                                {
                                        src->srcParams.gain[i] *= *gp;
                                }
                        }

                        return;
                }

                /*
                 * no position set, so set it to the listener
                 * postition.  We should probably set it to
                 * 0.0, 0.0, 0.0 instead.
                 *
                 * We fall through to get the MIN/MAX
                 */
                sp = listener_position;

                _alDebug(ALD_SOURCE, __FILE__, __LINE__,
                        "alf_da: setting to listener pos, probably not right");
        }

        /* set reference distance */
        temp = _alGetSourceParam( src, AL_REFERENCE_DISTANCE );
        if( temp != NULL ) {
                ref = * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_REFERENCE_DISTANCE, &ref );
        }

        /* set source specific gain */
        temp = _alGetSourceParam( src, AL_GAIN );
        if( temp != NULL ) {
                gain = * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_GAIN, &gain );
        }

        /* set source specific max distance */
        temp = _alGetSourceParam( src, AL_MAX_DISTANCE );
        if( temp != NULL ) {
                smax =  * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_MAX_DISTANCE, &smax );
        }

        /* get source specific rolloff factor */
        temp = _alGetSourceParam( src, AL_ROLLOFF_FACTOR );
        if( temp != NULL ) {
                rolloff =  * (ALfloat *) temp;
        } else {
                _alSourceGetParamDefault( AL_ROLLOFF_FACTOR, &rolloff );
        }

        sa = compute_sa( sp, smax, ref, gain, rolloff,
                         listener_position, df );

        for(i = 0; i < nc; i++) {
                src->srcParams.gain[i] *= sa;
        }

        return;
}

#if USE_TPITCH_LOOKUP
/*
 * init_tpitch_lookup( ALuint len )
 *
 * Initializes the tpitch lookup table.  See declaration of tpitch_lookup for
 * information on the layout and meaning of tpitch_lookup_init.
 */
static void init_tpitch_lookup( ALuint len ) {
        ALfloat scale;
        ALuint i;

        if(tpitch_lookup.len >= len) {
                /* We only go through the main loop if we
                 * haven't been initialized, or have been
                 * initialized with less memory than needed.
                 */
                return;
        }
        tpitch_lookup.len = len;

        /*
         * initialize time domain pitch filter lookup table
         */

        /*
         * For pitch < 1.0, we lower the frequency such that a pitch of
         * 0.5 corresponds to 1 octave drop.  Is this just a linear
         * application of the step?
         */
        for(i = 0; i < tpitch_lookup.max; i++) {
                ALfloat pitch;
                ALuint j;

                /* set offset part */
                free(tpitch_lookup.offsets[i]);
                tpitch_lookup.offsets[i] = malloc(sizeof *tpitch_lookup.offsets * len);
                /* set fractional part */
                free(tpitch_lookup.fractionals[i]);
                tpitch_lookup.fractionals[i] = malloc(sizeof *tpitch_lookup.fractionals * len);

                /* set iterate pitch */
                pitch = 2.0 * ((float)i / (float)tpitch_lookup.max);

                /* initialize offset table */
                scale = 0.0f;

                for(j = 0; j < len; j++)
                {
                        float foffset = j * pitch;
                        ALuint offset = (int) foffset;
                        float frac = foffset - offset;

                        tpitch_lookup.offsets[i][j] = offset;
                        tpitch_lookup.fractionals[i][j] = frac;
                }
        }

        return;
}
#endif

/*
 * alf_tdoppler
 *
 * This filter acts out the doppler effects, in the time domain as
 * opposed to frequency domain.  This filter works by computing the pitch
 * required to represent the doppler shift, and setting the AL_PITCH attribute
 * of the source directly.
 *
 * FIXME:
 *    It's not a good idea to mess with src's pitch.  Some method of
 *    expressing this computation without changing the source's attributes
 *    should be used.
 *
 */
void alf_tdoppler( ALuint cid,
                   AL_source *src,
                   UNUSED(AL_buffer *samp),
                   UNUSED(ALshort **buffers),
                   UNUSED(ALuint nc),
                   UNUSED(ALuint len) ) {
        AL_context *cc;
        ALfloat *sv; /* source velocity */
        ALfloat *sp; /* source position */
        ALfloat lv[3]; /* listener velocity */
        ALfloat lp[3]; /* listener position */
        ALfloat relative_velocity;  /* speed of source wrt listener */
#if 0
        ALfloat zeros[] = { 0.0, 0.0, 0.0 };
#endif
        AL_sourcestate *srcstate;
        ALfloat doppler_factor;
        ALfloat doppler_velocity;
        ALfloat doppler_pitch;

        /* initialize the mixrate */
        if(src->pitch.isset == AL_TRUE)
        {
                src->mixrate = src->pitch.data;
        }
        else
        {
                src->mixrate = 1.0;
        }

        /* lock context, get context specific stuff */
        _alcLockContext( cid );

        cc = _alcGetContext(cid);
        if( cc == NULL ) {
                /* cid is an invalid context id. */
                _alcUnlockContext( cid );

                return;
        }

        doppler_factor   = cc->doppler_factor;
        doppler_velocity = cc->doppler_velocity;

        _alcUnlockContext( cid );

        alGetListenerfv(AL_VELOCITY, lv);
        alGetListenerfv(AL_POSITION, lp);

        sp = _alGetSourceParam(src, AL_POSITION );
        sv = _alGetSourceParam(src, AL_VELOCITY );

        if(sp == NULL) {
                return;
        }

        if(sv == NULL) {
                /* no velocity set, no doppler effect */
                return;
        }

        if (fabs(doppler_factor) < 1.0E-6f) {
                /* doppler factor set to zero, no doppler effect */
                return;
        }

#if 0
        /* ToDo: duplicate test */
        if(sv == NULL) {
                /*
                 * if unset, set to the velocity to the
                 * zero vector.
                 */
                sv = zeros;
        }
#endif

        relative_velocity = _alVectorMagnitude(sv, lv);
        if(relative_velocity == 0.0) {
                /*
                 * no relative velocity, no doppler
                 *
                 * FIXME: use epsilon
                 */

                return;
        }


        srcstate = _alSourceQueueGetCurrentState(src);
        if(srcstate == NULL) {
                fprintf(stderr, "weird\n");
        }

        doppler_pitch = compute_doppler_pitch(lp, lv, sp, sv,
                                        doppler_factor, doppler_velocity);

        src->mixrate *= doppler_pitch;

#ifdef DEBUG
        if(src->mixrate < MIN_PITCH)
        {
                _alDebug(ALD_FILTER, __FILE__, __LINE__,
                         "Clamping src->mixrate %f\n",
                         src->mixrate);
        }
#endif

        src->mixrate = MAX(src->mixrate, MIN_PITCH);
        src->mixrate = MIN(src->mixrate, 2.0f);

        return;
}

/*
 * alf_minmax
 *
 * Implements min/max gain.  First min is applied, then max.
 */
void alf_minmax( UNUSED(ALuint cid),
                 AL_source *src,
                 UNUSED(AL_buffer *samp),
                 UNUSED(ALshort **buffers),
                 ALuint nc,
                 UNUSED(ALuint len) ) {
        ALfloat *amaxp = _alGetSourceParam( src, AL_MAX_GAIN );
        ALfloat *aminp = _alGetSourceParam( src, AL_MIN_GAIN );
        ALfloat attenuation_min;
        ALfloat attenuation_max;
        ALuint i;

        /*
         * if min or max are set, use them.  Otherwise, keep defaults
         */
        if(aminp != NULL) {
                attenuation_min = *aminp;
        } else {
                _alSourceGetParamDefault( AL_MIN_GAIN, &attenuation_min );
        }

        if(amaxp != NULL) {
                attenuation_max = *amaxp;
        } else {
                _alSourceGetParamDefault( AL_MAX_GAIN, &attenuation_max );
        }

        for(i = 0; i < nc; i++) {
                if( src->srcParams.gain[i] > attenuation_max ) {
                        src->srcParams.gain[i] = attenuation_max;
                } else if( src->srcParams.gain[i] < attenuation_min ) {
                        src->srcParams.gain[i] = attenuation_min;
                }
        }

        return;
}

/*
 * alf_listenergain
 *
 * Implements listener gain.
 */
void
alf_listenergain( UNUSED(ALuint cid),
                  AL_source *src,
                  UNUSED(AL_buffer *samp),
                  UNUSED(ALshort **buffers),
                  ALuint nc,
                  UNUSED(ALuint len) )
{
        ALfloat gain;
        ALuint i;
        alGetListenerfv(AL_GAIN, &gain);
        for(i = 0; i < nc; i++) {
                src->srcParams.gain[i] *= gain;
        }
}

/*
 * compute_doppler_pitch( ALfloat *object1, ALfloat *o1_vel,
 *                        ALfloat *object2, ALfloat *o2_vel,
 *                        ALfloat factor,
 *                        ALfloat speed )
 *
 * compute_doppler_pitch is meant to return a value spanning 0.5 to 1.5,
 * which is meant to simulate the frequency shift undergone by sources
 * in relative movement wrt the listener.
 */
static ALfloat compute_doppler_pitch( ALfloat *object1, ALfloat *o1_vel,
                                      ALfloat *object2, ALfloat *o2_vel,
                                      ALfloat factor,  /* doppler_factor */
                                      ALfloat speed ) { /* propagation_speed */
        ALfloat between[3];       /* Unit vector pointing in the direction
                                   * from one object to the other
                                   */
        ALfloat obj1V, obj2V;     /* Relative scalar velocity components */
        ALfloat ratio;            /* Ratio of relative velocities */
        ALfloat retval;           /* final doppler shift */

        /*
         * Set up the "between" vector which points from one object to the
         * other
         */
        between[0] = object2[0] - object1[0];
        between[1] = object2[1] - object1[1];
        between[2] = object2[2] - object1[2];

        _alVectorNormalize( between, between );

        /*
         * Compute the dot product of the velocity vector and the "between"
         * vector.
         *
         * The _alVectorDotp function is not set up for computing dot products
         * for actual vectors (it works for three points that define two
         * vectors from a common origin), so I'll do it here.
         */
        obj1V  = o1_vel[0] * between[0];
        obj1V += o1_vel[1] * between[1];
        obj1V += o1_vel[2] * between[2];

        /* Now compute the dot product for the second object */
        obj2V  = o2_vel[0] * between[0];
        obj2V += o2_vel[1] * between[1];
        obj2V += o2_vel[2] * between[2];

        /*
         * Apply the Doppler factor by modifying the source and listener
         * velocities.  This will exaggerate or reduce the Doppler
         * effect as expected.
         */
        obj1V *= factor;
        obj2V *= factor;

        /*
         * Now compute the obj1/obj2 velocity ratio, taking into account
         * the propagation speed.  This formula is straight from the spec.
         */
        obj1V = speed - obj1V;
        obj2V = speed + obj2V;
        ratio = obj1V / obj2V;

        /* Finally, return the ratio */
        retval = ratio;

        return retval;
}

#if USE_TPITCH_LOOKUP
/*
 * alf_tpitch
 *
 * this filter acts out AL_PITCH.
 *
 * This filter is implements AL_PITCH, but - oh-ho! - in the
 * time domain.  All that good fft mojo going to waste.
 */
void alf_tpitch( UNUSED(ALuint cid),
                 AL_source *src,
                 AL_buffer *samp,
                 ALshort **buffers,
                 ALuint nc,
                 ALuint len ) {
        ALshort *obufptr = NULL; /* pointer to unmolested buffer data */
        ALshort *bufptr  = NULL;  /* pointer to buffers[0..nc-1] */
        ALuint l_index;   /* index into lookup table */
        ALint ipos = 0;   /* used to store offsets temporarily */
        ALuint i;
        int *offsets;        /* pointer to set of offsets in lookup table */
        float *fractionals;  /* pointer to set of fractionals in lookup table */
        int bufchans;
        ALfloat pitch;

        pitch = src->mixrate;
        
        if (pitch == 1.0 && !(src->flags & ALS_NEEDPITCH)) {
                /*
                 * mixrate is at the default, so changing pitch is unnecessary.
                 */
                return;
        }

        bufchans = _alGetChannelsFromFormat(samp->format); /* we need bufchans to
                                                      * scale our increment
                                                      * of the soundpos,
                                                      * because of
                                                      * multichannel format
                                                      * buffers.
                                                      */
        /*
         * if pitch is out of range, return.
         */
        if(pitch <= 0.0f)
        {
                _alDebug(ALD_FILTER, __FILE__, __LINE__,
                        "pitch out of range: %f, clamping", pitch);
                pitch = 0.05f;
        }
        else if (pitch > 2.0f)
        {
                _alDebug(ALD_FILTER, __FILE__, __LINE__,
                        "pitch out of range: %f, clamping", pitch);
                pitch = 2.0f;
        }

        if(_alBufferIsCallback(samp) == AL_TRUE) {
                /* just debugging here, remove this block */

                _alDebug(ALD_BUFFER, __FILE__, __LINE__,
                      "No tpitch support for callbacks yet");

                /* _alSetError(cid, AL_INVALID_OPERATION); */
                return;
        }

        /*
         *  We need len in samples, not bytes.
         */
        len /= sizeof(ALshort);

        /* convert pitch into index in our lookup table */
        l_index = (pitch / 2.0) * tpitch_lookup.max;

        /*
         * sanity check.
         */
        if(l_index >= tpitch_lookup.max) {
                l_index = tpitch_lookup.max - 1;
        }

        _alDebug(ALD_FILTER, __FILE__, __LINE__,
              "pitch %f l_index %d", pitch, l_index);

        /*
         * offsets is our set of pitch-scaled offsets, 0...pitch * len.
         *
         * Well, sort of.  0...pitch * len, but with len scaled such
         * that we don't suffer a overrun if the buffer's original
         * data is too short.
         */
        offsets = tpitch_lookup.offsets[ l_index ];

#ifdef DEBUG_MEM
        assert(l_index < TPITCH_MAX);
#endif

        /*
         * Iterate over each buffers[0..nc-1]
         */
        for(i = 0; i < nc; i++) {
                ALint clen = len;
                int j;

                /*
                 * Kind of breaking convention here and actually using
                 * the original buffer data instead of just resampling
                 * inside the passed buffer data.  This is because we
                 * won't have enough data to resample pitch > 1.0.
                 *
                 * We offset our original buffer pointer by the source's
                 * current position, but in samples, not in bytes
                 * (which is what src->srcParams.soundpos is in).
                 */
                obufptr  = samp->orig_buffers[i];
                obufptr += src->srcParams.soundpos / sizeof *obufptr;

#ifdef DEBUG_MEM
                assert(samp->orig_buffers[i]);
                assert(src->srcParams.soundpos < samp->size);
#endif

                if(l_index == tpitch_lookup.middle ) {
                        /* when this predicate is true, the pitch is
                         * equal to 1, which means there is no change.
                         * Therefore, we short circuit.
                         *
                         * Because we're incrementing the soundpos here,
                         * we can't just return.
                         */

                        continue;
                }

                /*
                 * set bufptr to the pcm channel that we
                 * are about to change in-place.
                 */
                bufptr = buffers[i];

                /*
                 * We mess with offsets in the loop below, so reset it
                 * after each iteration.
                 */
                offsets = tpitch_lookup.offsets[ l_index ];
                fractionals = tpitch_lookup.fractionals[ l_index ];

                /* don't run past end */
                if(((clen + 1) * pitch * sizeof(ALshort)) >=
                   (samp->size - src->srcParams.soundpos))
                {
                        clen = samp->size - src->srcParams.soundpos;
                        clen /= pitch;
                        clen /= sizeof(ALshort);
                        clen -= 1;
                }

                /*
                 * this is where the "resampling" takes place.  We do a
                 * very little bit on unrolling here, and it shouldn't
                 * be necessary, but seems to improve performance quite
                 * a bit.
                 */
                for(j = 0; j < clen; j++)
                {
#if USE_LRINT
                        {
                                int offset = offsets[j];
                                int nextoffset = offsets[j+1];
                                float frac = fractionals[j];
                                float firstsample = obufptr[offset];
                                float nextsample = obufptr[nextoffset];
                                int finalsample;

                                /* do a little interpolation */
                                finalsample = lrintf(firstsample +
                                            frac * (nextsample - firstsample));

                                finalsample = MIN(finalsample, canon_max);
                                bufptr[j] =   MAX(finalsample, canon_min);
                        }
#else
                        {
                                int offset = offsets[j];
                                int nextoffset = offsets[j+1];
                                float frac = fractionals[j];
                                int firstsample = obufptr[offset];
                                int nextsample = obufptr[nextoffset];
                                int finalsample;

                                /* do a little interpolation */
                                finalsample = firstsample +
                                            frac * (nextsample - firstsample);

                                finalsample = MIN(finalsample, canon_max);
                                bufptr[j] =   MAX(finalsample, canon_min);
                        }
#endif
                }

                /* zero off end */
                memset(&bufptr[j], 0, (len-j)*sizeof *bufptr);
        }

        /*
         *  Set offsets to a known good state.
         */
        offsets = tpitch_lookup.offsets[l_index];

        /*
         *  AL_PITCH (well, alf_tpitch actually) require that the
         *  main mixer func does not increment the source's soundpos,
         *  so we must increment it here.  If we detect an overrun, we
         *  must reset the src's soundpos to something reasonable.
         */
        ipos = (int) (len * pitch);
        src->srcParams.soundpos += bufchans * ipos * sizeof(ALshort);

        if(src->srcParams.soundpos > samp->size)
        {
                /*
                 * we've reached the end of this sample.
                 *
                 * Since we're handling the soundpos incrementing for
                 * this source (usually done in _alMixSources), we have
                 * to handle all the special cases here instead of
                 * delegating them.
                 *
                 * These include callback, looping, and streaming
                 * sources.  For now, we just handle looping and
                 * normal sources, as callback sources will probably
                 * require added some special case logic to _alSplitSources
                 * to give up a little more breathing room.
                 */
                if( _alSourceIsLooping( src ) == AL_TRUE ) {
                        /*
                         * looping source
                         *
                         * FIXME:
                         *      This isn't right.  soundpos should be set to
                         *      something different, and we may need to carry
                         *      over info so that the sound loops properly.
                         */

                        /* FIXME: kind of kludgy */
                        src->srcParams.soundpos = 0;
                } else {
                        /*
                         * let _alMixSources know it's time for this source
                         * to die.
                         */
                        _alDebug(ALD_FILTER, __FILE__, __LINE__,
                                 "tpitch: source ending");
                        src->srcParams.soundpos = samp->size;
                }
        }

        return;
}
#else
/*
 * alf_tpitch
 *
 * this filter acts out AL_PITCH.
 *
 * This filter is implements AL_PITCH, but - oh-ho! - in the
 * time domain.  All that good fft mojo going to waste.
 */
void alf_tpitch( UNUSED(ALuint cid),
                 AL_source *src,
                 AL_buffer *samp,
                 ALshort **buffers,
                 ALuint nc,
                 ALuint len )
{
        ALshort *obufptr = NULL; /* pointer to unmolested buffer data */
        ALshort *bufptr  = NULL;  /* pointer to buffers[0..nc-1] */
        ALint ipos = 0;   /* used to store offsets temporarily */
        ALuint i;
        ALuint clen;
        int bufchans;
        ALfloat pitch;

        pitch = src->mixrate;
        
        if (pitch == 1.0 && !(src->flags & ALS_NEEDPITCH)) {
                /*
                 * mixrate is at the default, so changing pitch is unnecessary.
                 */
                return;
        }

        bufchans = _alGetChannelsFromFormat(samp->format); /* we need bufchans to
                                                      * scale our increment
                                                      * of the soundpos,
                                                      * because of
                                                      * multichannel format
                                                      * buffers.
                                                      */
        /*
         * if pitch is out of range, clamp.
         */
        pitch = MIN(pitch, 2.0f);
        pitch = MAX(pitch, MIN_PITCH);

        /*
         *  We need len in samples, not bytes.
         */
        len /= sizeof(ALshort);

        _alDebug(ALD_FILTER, __FILE__, __LINE__, "pitch %f", pitch);

        /*
         * Iterate over each buffers[0..nc-1]
         */
        for(i = 0; i < nc; i++) {
                ALuint j;

                if(pitch == 1.0f)
                {
                        continue;
                }

                /*
                 * Kind of breaking convention here and actually using
                 * the original buffer data instead of just resampling
                 * inside the passed buffer data.  This is because we
                 * won't have enough data to resample pitch > 1.0.
                 *
                 * We offset our original buffer pointer by the source's
                 * current position, but in samples, not in bytes
                 * (which is what src->srcParams.soundpos is in).
                 */
                obufptr  = samp->orig_buffers[i];
                obufptr += src->srcParams.soundpos / sizeof *obufptr;

                /*
                 * set bufptr to the pcm channel that we
                 * are about to change in-place.
                 */
                bufptr = buffers[i];

                clen = len;

                /* don't run past end */
                if(((clen + 1) * pitch * sizeof(ALshort)) >=
                   (samp->size - src->srcParams.soundpos))
                {
                        clen = samp->size - src->srcParams.soundpos;
                        clen /= pitch;
                        clen /= sizeof(ALshort);
                        clen -= 1;
                }

                /*
                 * this is where the "resampling" takes place.  We do a
                 * very little bit on unrolling here, and it shouldn't
                 * be necessary, but seems to improve performance quite
                 * a bit.
                 */
                for(j = 0; j < clen; j++)
                {
                        /* make sure we don't go past end of last source */
#ifdef DEBUG_FILTER
                        assert(((j+1)*pitch)*2 <
                                samp->size - src->srcParams.soundpos);
#endif
                        {
                                float foffset = j * pitch;
                                int offset = (int) foffset;
                                float frac = foffset - offset;
                                int firstsample = obufptr[(int) (j * pitch)];
                                int nextsample = obufptr[(int)((j+1) * pitch)];
                                int finalsample;

                                /* do a little interpolation */
                                finalsample = firstsample +
                                            frac * (nextsample - firstsample);

                                finalsample = MIN(finalsample, canon_max);
                                bufptr[j] =   MAX(finalsample, canon_min);
                        }
                }

                /* JIV FIXME: use memset */
                for( ; j < len; j++)
                {
                        bufptr[j] = 0;
                }
        }

        /*
         *  AL_PITCH (well, alf_tpitch actually) require that the
         *  main mixer func does not increment the source's soundpos,
         *  so we must increment it here.  If we detect an overrun, we
         *  must reset the src's soundpos to something reasonable.
         */
        ipos = (int) (len * pitch);
        src->srcParams.soundpos += bufchans * ipos * sizeof(ALshort);

        if(src->srcParams.soundpos > samp->size)
        {
                /*
                 * we've reached the end of this sample.
                 *
                 * Since we're handling the soundpos incrementing for
                 * this source (usually done in _alMixSources), we have
                 * to handle all the special cases here instead of
                 * delegating them.
                 *
                 * These include callback, looping, and streaming
                 * sources.  For now, we just handle looping and
                 * normal sources, as callback sources will probably
                 * require added some special case logic to _alSplitSources
                 * to give up a little more breathing room.
                 */
                if( _alSourceIsLooping( src ) == AL_TRUE ) {
                        /*
                         * looping source
                         *
                         * FIXME:
                         *      This isn't right.  soundpos should be set to
                         *      something different, and we may need to carry
                         *      over info so that the sound loops properly.
                         */

                        /* FIXME: kind of kludgy */
                        src->srcParams.soundpos = 0;
                } else {
                        /*
                         * let _alMixSources know it's time for this source
                         * to die.
                         */
                        _alDebug(ALD_FILTER, __FILE__, __LINE__,
                                 "tpitch: source ending");

                        src->srcParams.soundpos = samp->size;
                }
        }

        return;
}
#endif


/*
 * compute_sa( ALfloat *source_pos, ALfloat source_max,
 *             ALfloat source_ref, ALfloat source_gain,
 *             ALfloat source_rolloff,
 *             ALfloat *speaker_pos,
 *             ALfloat (*df)( ALfloat dist, ALfloat rolloff,
 *                            ALfloat ref, ALfloat max))
 *
 * computes distance attenuation with respect to a speaker position.
 *
 * This is some normalized value which gets expotenially closer to 1.0
 * as the source approaches the listener.  The minimum attenuation is
 * AL_CUTTOFF_ATTENUATION, which approached when the source approaches
 * the max distance.
 *
 * source_pos = source position   [x/y/z]
 * source_max = source specific max distance
 * speaker_pos = speaker position [x/y/z]
 * ref        = source's reference distance
 * df         = distance model function
 * max        = maximum distance, beyond which everything is clamped at
 *              some small value near, but not equal to, zero.
 */
static ALfloat
compute_sa( ALfloat *source_pos, ALfloat source_max,
            ALfloat source_ref, ALfloat source_gain,
            ALfloat source_rolloff,
            ALfloat *speaker_pos,
            ALfloat (*df)( ALfloat dist, ALfloat rolloff, ALfloat ref, ALfloat max))
{
        ALfloat retval;

        /* "Optimize" for rolloff == 0.0 */
        if (source_rolloff > 0.0) {
                ALfloat distance;
                distance = _alVectorMagnitude( source_pos, speaker_pos );
                retval = source_gain * df( distance, source_rolloff, source_ref, source_max );
        } else {
                retval = source_gain;
        }

        if( retval > 1.0 ) {
                return 1.0;
        }

        if(retval < _AL_CUTTOFF_ATTENUATION) {
                return _AL_CUTTOFF_ATTENUATION;
        }

        return retval;
}

/*
 * alf_panning
 *
 */

void alf_panning( ALuint cid,
                 AL_source *src,
                 UNUSED(AL_buffer *samp),
                 UNUSED(ALshort **buffers),
                 ALuint nc,
                 UNUSED(ALuint len) ) {
        ALfloat lp[3]; /* listener position */
        ALfloat *sp; /* source position */
        ALfloat *sd; /* speaker position */
        ALfloat m;
        ALfloat sa;
        ALuint i;

        alGetListenerfv(AL_POSITION, lp);
        sp = _alGetSourceParam(src, AL_POSITION );

        if ((sp == NULL) || (lp == NULL)) {
                return;
        }

        m = _alVectorMagnitude(lp, sp);
        if (m == 0) {
                /* should this use epsilon? */
                return;
        }

        for (i = 0; i < nc; i++) {
                sd = _alcGetSpeakerPosition(cid, i);
                sa = _alVectorDotp(lp, sp, sd) / m;
                sa += 1.0;

                src->srcParams.gain[i] *= sa;
        }
}