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

/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
 * vi:set ts=8:
 *
 * alc_speaker.c
 *
 * functions related to the position of the speakers in the alc world.
 *
 * This speaker handling stuff is a little goofy.  Rotation code should be
 * rewritten.  Also, the assumption is that speaker positions correspond to an
 * interleaved layout of LRLRLR, or LF RF LB RB.  This might not always be the
 * case.
 */

#include "al_siteconfig.h"

#include <AL/al.h>
#include <AL/alc.h>

#include "al_debug.h"
#include "al_main.h"
#include "al_vector.h"
#include "al_matrix.h"

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

#ifndef M_SQRT1_2
# define M_SQRT1_2      0.70710678118654752440  /* 1/sqrt(2) */
#endif

/*
 * _alcSpeakerMove( ALuint cid )
 *
 * Moves speakers for context named by cid, using listener orientation and
 * position as modifiers.
 *
 * If cid is invalid, set ALC_INVALID_CONTEXT.
 *
 * assumes context cid is locked
 *
 * FIXME:
 *    please check my math
 */
void _alcSpeakerMove( ALuint cid ) {
        AL_context *cc;
        ALfloat vec[3];
        ALfloat *pos;    /* listener position */
        ALfloat *ori;    /* listener orientation */
        ALfloat ipos[3]; /* inverse listener position */
        ALuint i;
        ALmatrix *m;
        ALmatrix *pm;
        ALmatrix *rm;

        cc = _alcGetContext( cid );
        if(cc == NULL) {
                _alDebug(ALD_CONTEXT, __FILE__, __LINE__,
                      "_alcSpeakerMove: invalid context id %d", cid);

                _alcSetError( ALC_INVALID_CONTEXT );

                return;
        }

        pos = cc->listener.position;
        ori = cc->listener.orientation;

        m  = _alMatrixAlloc(3, 3);
        pm = _alMatrixAlloc(1, 3);
        rm = _alMatrixAlloc(1, 3);

        _alVectorCrossProduct(vec, ori + 0, ori + 3);
        _alVectorNormalize(m->data[0], vec);

        _alVectorCrossProduct(vec, m->data[0], ori + 0);
        _alVectorNormalize(m->data[1], vec);

        _alVectorNormalize(m->data[2], ori + 0);

        /* reset speaker position */
        _alcSpeakerInit(cid);

        _alVectorInverse( ipos, cc->listener.position );

        /* rotate about at and up vectors */
        for(i = 0; i < _alcGetNumSpeakers(cid); i++) {
                _alVectorTranslate(pm->data[0],
                                   cc->_speaker_pos[i].pos, ipos);

                _alMatrixMul(rm, pm, m);

                _alVectorTranslate(cc->_speaker_pos[i].pos,
                                   rm->data[0], pos);
        }

        _alDebug(ALD_MATH, __FILE__, __LINE__,
                "SpAdj: l/r [%f|%f|%f] [%f|%f|%f]",
                cc->_speaker_pos[0].pos[0],
                cc->_speaker_pos[0].pos[1],
                cc->_speaker_pos[0].pos[2],

                cc->_speaker_pos[1].pos[0],
                cc->_speaker_pos[1].pos[1],
                cc->_speaker_pos[1].pos[2]);

        _alMatrixFree(m);
        _alMatrixFree(pm);
        _alMatrixFree(rm);

        return;
}

/*
 * _alcSpeakerInit( ALuint cid )
 *
 * Initialize position wrt listener, w/o rt orientation.
 *
 * assumes locked context
 */
void _alcSpeakerInit( ALuint cid ) {
        AL_context  *cc;
        AL_listener *lis;
        ALfloat *lpos;
        ALfloat sdis; /* scaled distance */
        ALuint i;
        ALuint num;

        cc  = _alcGetContext( cid );
        lis = _alcGetListener( cid );
        if(cc == NULL) {
                /* invalid cid */
                _alDebug(ALD_CONTEXT, __FILE__, __LINE__,
                        "_alcSpeakerInit: invalid cid 0x%x", cid );

                return;
        }

        if(lis == NULL) {
                /* weird */
                return;
        }

        lpos = lis->position;

        /*
         * A speaker distance of one simplifies the math later.
         */
        sdis = 1.0f;

        _alDebug(ALD_CONTEXT, __FILE__, __LINE__,
                "_alcSpeakerInit: ( sdis %f )", sdis );

        for (i = 0; i < _ALC_MAX_CHANNELS; i++)
        {
                cc->_speaker_pos[i].pos[0]   = lpos[0];
                cc->_speaker_pos[i].pos[1]   = lpos[1];
                cc->_speaker_pos[i].pos[2]   = lpos[2];
        }

        num = _alcGetNumSpeakers(cid);

        /* fourpoint */

        if (num >= 4)
        {
                sdis *= M_SQRT1_2;

                cc->_speaker_pos[ALS_LEFT].pos[2] += sdis;
                cc->_speaker_pos[ALS_RIGHT].pos[2] += sdis;

                cc->_speaker_pos[ALS_LEFTS].pos[0] -= sdis;
                cc->_speaker_pos[ALS_LEFTS].pos[2] -= sdis;

                cc->_speaker_pos[ALS_RIGHTS].pos[0] += sdis;
                cc->_speaker_pos[ALS_RIGHTS].pos[2] -= sdis;
        }

        /* stereo */

        if (num >= 2)
        {
                cc->_speaker_pos[ALS_LEFT].pos[0] -= sdis;
                cc->_speaker_pos[ALS_RIGHT].pos[0] += sdis;
        }
        return;
}

/*
 * _alcGetNumSpeakers( ALuint cid )
 *
 * Returns number of speakers available for context named cid.
 *
 * assumes locked context
 */
ALuint _alcGetNumSpeakers( ALuint cid ) {
        return _alGetChannelsFromFormat( _alcGetWriteFormat( cid ) );
}

/*
 * _alcGetSpeakerPosition( ALuint cid, ALuint speaker_num )
 *
 * Returns 3-float tuple giving the speaker position for speaker with offset
 * speaker_num for the context named cid, or NULL on error.
 *
 * assumes locked context
 */
ALfloat *_alcGetSpeakerPosition( ALuint cid, ALuint speaker_num ) {
        AL_context *cc;
        ALuint nc;

        cc = _alcGetContext( cid );
        if(cc == NULL) {
                return NULL;
        }

        nc = _alcGetNumSpeakers( cid );

        if( speaker_num >= nc ) {
                return NULL;
        }

        return cc->_speaker_pos[speaker_num].pos;
}