source: downloads/openal-0.0.8/src/al_state.c @ 24

/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
 * vi:set ts=8:
 *
 * al_state.c
 *
 * Per-context state management.
 *
 */
#include "al_siteconfig.h"

#include <AL/al.h>

#include "al_distance.h"
#include "al_error.h"
#include "al_ext.h"

/*
 * A few general remarks about the code below:
 *
 *    * When there is no current context, we set an AL_INVALID_OPERATION. Even
 *      without a context for recording this error, this is nice for
 *      debugging.
 *
 *    * As a general contract with the user, we never modify any data via
 *      pointers if an error condition occurs.
 *
 *    * Getting and locking the context should be done in a single atomic
 *      operation, but our internal API is not yet capable of this.
 *
 *    * We should somehow hook in the extension mechanism here.
 *
 */

void
alEnable( ALenum param )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return;
        }
        _alcDCLockContext();

        switch (param) {
        default:
                _alDCSetError( AL_INVALID_ENUM );
                break;
        }

        _alcDCUnlockContext();
}

void
alDisable( ALenum param )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return;
        }
        _alcDCLockContext();

        switch (param) {
        default:
                _alDCSetError( AL_INVALID_ENUM );
                break;
        }

        _alcDCUnlockContext();
}

ALboolean
alIsEnabled( ALenum param )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return AL_FALSE;
        }
        _alcDCLockContext();

        switch (param) {
        default:
                _alDCSetError( AL_INVALID_ENUM );
                break;
        }

        _alcDCUnlockContext();
        return AL_FALSE;
}

const ALchar*
alGetString( ALenum param )
{
        const ALchar *value;
        ALchar extensions[1024]; /* TODO: Ugly! */

        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return NULL;
        }
        _alcDCLockContext();

        switch (param) {
        case AL_VERSION:
                value = "1.1";
                break;
        case AL_RENDERER:
                value = "Software";
                break;
        case AL_VENDOR:
                value = "OpenAL Community";
                break;
        case AL_EXTENSIONS:
                _alGetExtensionStrings( extensions, sizeof( extensions ) );
                value = extensions;
                break;
        case AL_NO_ERROR:
                value = "No Error";
                break;
        case AL_INVALID_NAME:
                value = "Invalid Name";
                break;
        case AL_INVALID_ENUM:
                value = "Invalid Enum";
                break;
        case AL_INVALID_VALUE:
                value = "Invalid Value";
                break;
        case AL_INVALID_OPERATION:
                value = "Invalid Operation";
                break;
        case AL_OUT_OF_MEMORY:
                value = "Out of Memory";
                break;
        default:
                value = NULL;
                _alDCSetError( AL_INVALID_ENUM );
                break;
        }

        _alcDCUnlockContext();
        return value;
}

#define MAX_DATA_ENTRIES_FILLED 1

/* everything is better than code duplication, even macros... */

#define DEFINE_GETTER(type,conv,namev,name)             \
void                                                    \
namev( ALenum param, type *data )                       \
{                                                       \
        AL_context *cc = _alcDCGetContext();            \
        if( cc == NULL ) {                              \
                _alDCSetError( AL_INVALID_OPERATION );  \
                return;                                 \
        }                                               \
        _alcDCLockContext();                            \
                                                        \
        switch( param ) {                               \
        case AL_DOPPLER_FACTOR:                         \
                data[0] = conv(cc->doppler_factor);     \
                break;                                  \
        case AL_DOPPLER_VELOCITY:                       \
                data[0] = conv(cc->doppler_velocity);   \
                break;                                  \
        case AL_SPEED_OF_SOUND:                         \
                data[0] = conv(cc->speed_of_sound);     \
                break;                                  \
        case AL_DISTANCE_MODEL:                         \
                data[0] = conv(cc->distance_model);     \
                break;                                  \
        default:                                        \
                _alDCSetError( AL_INVALID_ENUM );       \
                break;                                  \
        }                                               \
                                                        \
        _alcDCUnlockContext();                          \
}                                                       \
                                                        \
type                                                    \
name( ALenum param )                                    \
{                                                       \
        type buf[MAX_DATA_ENTRIES_FILLED];              \
        namev(param, buf);                              \
        return buf[0];                                  \
}

#define CONV_BOOLEAN(x) ((x) ? AL_TRUE : AL_FALSE)
#define CONV_INTEGER(x) ((ALint)(x))
#define CONV_FLOAT(x)   ((ALfloat)(x))
#define CONV_DOUBLE(x)  ((ALdouble)(x))

DEFINE_GETTER(ALboolean,CONV_BOOLEAN,alGetBooleanv,alGetBoolean)
DEFINE_GETTER(ALint,CONV_INTEGER,alGetIntegerv,alGetInteger)
DEFINE_GETTER(ALfloat,CONV_FLOAT,alGetFloatv,alGetFloat)
DEFINE_GETTER(ALdouble,CONV_DOUBLE,alGetDoublev,alGetDouble)

#undef DEFINE_GETTER

void
alDopplerFactor( ALfloat value )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return;
        }
        _alcDCLockContext();

        if( value < 0.0f ) {
                _alDCSetError( AL_INVALID_VALUE );
                _alcDCUnlockContext();
                return;
        }
        cc->doppler_factor = value;

        _alcDCUnlockContext();
}

void
alDopplerVelocity( ALfloat value )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return;
        }
        _alcDCLockContext();

        if( value <= 0.0f ) {
                _alDCSetError( AL_INVALID_VALUE );
                _alcDCUnlockContext();
                return;
        }
        cc->doppler_velocity = value;

        _alcDCUnlockContext();
}

void
alSpeedOfSound( ALfloat value )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return;
        }
        _alcDCLockContext();

        if( value <= 0.0f ) {
                _alDCSetError( AL_INVALID_VALUE );
                _alcDCUnlockContext();
                return;
        }
        cc->speed_of_sound = value;

        _alcDCUnlockContext();
}

void
alDistanceModel( ALenum distanceModel )
{
        AL_context *cc = _alcDCGetContext();
        if( cc == NULL ) {
                _alDCSetError( AL_INVALID_OPERATION );
                return;
        }
        _alcDCLockContext();

        switch( distanceModel ) {
        case AL_NONE:
        case AL_INVERSE_DISTANCE:
        case AL_INVERSE_DISTANCE_CLAMPED:
        case AL_LINEAR_DISTANCE:
        case AL_LINEAR_DISTANCE_CLAMPED:
        case AL_EXPONENT_DISTANCE:
        case AL_EXPONENT_DISTANCE_CLAMPED:
                cc->distance_model = distanceModel;
                _alUpdateDistanceModel(cc);
                break;
        default:
                _alDCSetError( AL_INVALID_ENUM );
                break;
        }

        _alcDCUnlockContext();
}