999 lines
24 KiB
C
999 lines
24 KiB
C
// Emacs style mode select -*- C++ -*-
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (C) 2001 by DooM Legacy Team.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file
|
|
/// \brief General driver for 3D sound system
|
|
///
|
|
/// Implementend via OpenAL API
|
|
|
|
#ifdef _WINDOWS
|
|
//#define WIN32_LEAN_AND_MEAN
|
|
#define RPC_NO_WINDOWS_H
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
FILE* logstream = NULL;
|
|
#else
|
|
#include <stdarg.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#ifndef HAVE_SDL // let not make a logstream here is we are inline the HW3D in the SDL binary
|
|
FILE* logstream = NULL;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
#include <al.h> //Main AL
|
|
#include <alc.h> //Helpers
|
|
#else
|
|
#include <AL/al.h> //Main AL
|
|
#include <AL/alc.h> //Helpers
|
|
#endif
|
|
|
|
#define _CREATE_DLL_
|
|
#include "../../doomdef.h"
|
|
#include "../hw3dsdrv.h"
|
|
|
|
//#undef DEBUG_TO_FILE
|
|
//#if defined ( HAVE_SDL ) && !defined ( LOGMESSAGES )
|
|
#define DEBUG_TO_FILE
|
|
//#endif
|
|
|
|
// Internal sound stack
|
|
typedef struct stack_snd_s
|
|
{
|
|
ALuint ALsource;// 3D data of 3D source
|
|
|
|
ALint sfx_id;// Currently unused
|
|
|
|
ALint LRU;// Currently unused
|
|
|
|
ALboolean permanent;// Flag of static source
|
|
} stack_snd_t;
|
|
|
|
#ifndef AL_INVALID
|
|
#define AL_INVALID (-1)
|
|
#endif
|
|
|
|
static I_Error_t I_ErrorOpenAl = NULL;
|
|
static stack_snd_t *ALstack = NULL; // Sound stack
|
|
static ALsizei allocated_sounds = 0; // Size of stack
|
|
static ALsizei allocate_delta = 16;
|
|
static ALCdevice *ALCDevice = NULL;
|
|
static ALCcontext *ALContext = NULL;
|
|
static ALenum ALo_Lasterror = AL_NO_ERROR;
|
|
static ALenum ALCo_Lasterror = ALC_NO_ERROR;
|
|
|
|
static ALenum ALo_GetError(ALvoid)
|
|
{
|
|
ALo_Lasterror = alGetError();
|
|
return ALo_Lasterror;
|
|
}
|
|
|
|
static ALenum ALCo_GetError(ALvoid)
|
|
{
|
|
ALCo_Lasterror = alcGetError(ALCDevice);
|
|
return ALCo_Lasterror;
|
|
}
|
|
|
|
static ALfloat ALvol(ALint vol, ALsizei step)
|
|
{
|
|
return ((ALfloat)vol)/(ALfloat)step;
|
|
}
|
|
|
|
/*
|
|
static ALfloat Alpitch(ALint pitch)
|
|
{
|
|
#if 1
|
|
pitch = NORMAL_PITCH;
|
|
#endif
|
|
return pitch < NORMAL_PITCH ?
|
|
(float)(pitch + NORMAL_PITCH) / (NORMAL_PITCH * 2)
|
|
:(float)pitch / (float)NORMAL_PITCH;
|
|
}
|
|
*/
|
|
|
|
static const ALchar *GetALErrorString(ALenum err)
|
|
{
|
|
switch (err)
|
|
{
|
|
case AL_NO_ERROR:
|
|
return "There no error";
|
|
break;
|
|
|
|
case AL_INVALID_NAME:
|
|
return "Invalid name";
|
|
break;
|
|
|
|
case AL_INVALID_ENUM:
|
|
return "Invalid enum";
|
|
break;
|
|
|
|
case AL_INVALID_VALUE:
|
|
return "Invalid value";
|
|
break;
|
|
|
|
case AL_INVALID_OPERATION:
|
|
return "Invalid operation";
|
|
break;
|
|
|
|
case AL_OUT_OF_MEMORY:
|
|
return "Out Of Memory";
|
|
break;
|
|
|
|
default:
|
|
return alGetString(err);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static const ALchar *GetALCErrorString(ALenum err)
|
|
{
|
|
switch (err)
|
|
{
|
|
case ALC_NO_ERROR:
|
|
return "There no error";
|
|
break;
|
|
|
|
case ALC_INVALID_DEVICE:
|
|
return "Invalid Device";
|
|
break;
|
|
|
|
case ALC_INVALID_CONTEXT:
|
|
return "Invalid Context";
|
|
break;
|
|
|
|
case ALC_INVALID_ENUM:
|
|
return "Invalid enum";
|
|
break;
|
|
|
|
case ALC_INVALID_VALUE:
|
|
return "Invalid value";
|
|
break;
|
|
|
|
case ALC_OUT_OF_MEMORY:
|
|
return "Out Of Memory";
|
|
break;
|
|
|
|
default:
|
|
return alcGetString(ALCDevice, err);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/***************************************************************
|
|
*
|
|
* DBG_Printf
|
|
* Output error messages to debug log if DEBUG_TO_FILE is defined,
|
|
* else do nothing
|
|
*
|
|
**************************************************************
|
|
*/
|
|
// -----------------+
|
|
// DBG_Printf : Output error messages to debug log if DEBUG_TO_FILE is defined,
|
|
// : else do nothing
|
|
// Returns :
|
|
// -----------------+
|
|
FUNCPRINTF void DBG_Printf(const char *lpFmt, ... )
|
|
{
|
|
#ifdef DEBUG_TO_FILE
|
|
char str[4096] = "";
|
|
va_list arglist;
|
|
|
|
va_start(arglist, lpFmt);
|
|
vsnprintf(str, 4096, lpFmt, arglist);
|
|
va_end(arglist);
|
|
if (logstream)
|
|
fwrite(str, strlen(str), 1 , logstream);
|
|
#else
|
|
lpFmt = NULL;
|
|
#endif
|
|
}
|
|
|
|
/***************************************************************
|
|
*
|
|
* Grow internal sound stack by allocate_delta amount
|
|
*
|
|
***************************************************************
|
|
*/
|
|
static ALboolean reallocate_stack(void)
|
|
{
|
|
stack_snd_t *new_stack;
|
|
if (ALstack)
|
|
new_stack = realloc(ALstack, sizeof (stack_snd_t) * (allocated_sounds + allocate_delta));
|
|
else
|
|
new_stack = malloc(sizeof (stack_snd_t) * (allocate_delta));
|
|
if (new_stack)
|
|
{
|
|
ALsizei clean_stack;
|
|
ALstack = new_stack;
|
|
memset(&ALstack[allocated_sounds], 0, allocate_delta * sizeof (stack_snd_t));
|
|
for (clean_stack = allocated_sounds; clean_stack < allocated_sounds; clean_stack++)
|
|
ALstack[clean_stack].ALsource = (ALuint)AL_INVALID;
|
|
allocated_sounds += allocate_delta;
|
|
return AL_TRUE;
|
|
}
|
|
return AL_FALSE;
|
|
}
|
|
|
|
|
|
/***************************************************************
|
|
*
|
|
* Destroys source in stack
|
|
*
|
|
***************************************************************
|
|
*/
|
|
static ALvoid kill_sound(stack_snd_t *snd)
|
|
{
|
|
if (alIsSource(snd->ALsource))
|
|
alDeleteSources(1,&snd->ALsource);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alDeleteSources, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
memset(snd,0, sizeof (stack_snd_t));
|
|
snd->ALsource = (ALuint)AL_INVALID;
|
|
}
|
|
|
|
/***************************************************************
|
|
*
|
|
* Returns free (unused) source stack slot
|
|
* If none available sound stack will be increased
|
|
*
|
|
***************************************************************
|
|
*/
|
|
static ALsizei find_handle(void)
|
|
{
|
|
ALsizei free_sfx = 0;
|
|
stack_snd_t *snd;
|
|
|
|
for (snd = ALstack; free_sfx < allocated_sounds; snd++, free_sfx++)
|
|
{
|
|
if (snd->permanent)
|
|
continue;
|
|
if (snd->ALsource==(ALuint)AL_INVALID)
|
|
break;
|
|
if (!alIsSource(snd->ALsource))
|
|
break;
|
|
ALo_GetError();
|
|
if (snd->sfx_id == 0)
|
|
break;
|
|
}
|
|
|
|
// No suitable resource found so increase sound stack
|
|
//DBG_Printf("sfx chan %d\n", free_sfx);
|
|
if (free_sfx == allocated_sounds)
|
|
{
|
|
DBG_Printf("No free or same sfx found so increase stack (currently %d srcs)\n", allocated_sounds);
|
|
free_sfx = reallocate_stack() ? free_sfx : (ALsizei)AL_INVALID;
|
|
}
|
|
return free_sfx;
|
|
}
|
|
|
|
static ALvoid ALSetPan(ALuint sid, INT32 sep)
|
|
{
|
|
ALfloat facing[3] ={0.0f, 0.0f, 0.0f}; //Alam: bad?
|
|
const ALfloat fsep = (ALfloat)sep;
|
|
const ALfloat nsep = (ALfloat)NORMAL_SEP;
|
|
if (sep)
|
|
{
|
|
facing[0] = (ALfloat)(fsep/nsep);
|
|
facing[2] = 1.0f;
|
|
}
|
|
alSourcefv(sid, AL_POSITION, facing);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alSourcefv, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Initialise driver and listener
|
|
*
|
|
*****************************************************************************/
|
|
EXPORT INT32 HWRAPI( Startup ) (I_Error_t FatalErrorFunction, snddev_t *snd_dev)
|
|
{
|
|
ALenum model = AL_INVERSE_DISTANCE_CLAMPED;
|
|
ALCboolean inited = ALC_FALSE;
|
|
ALCint AlSetup[8] = {ALC_FREQUENCY,22050,ALC_REFRESH,35,ALC_SYNC,AL_FALSE,ALC_INVALID,ALC_INVALID};
|
|
#if (defined (_WIN32) || defined (_WIN64)) && 0
|
|
const ALCubyte *ALCdriver = alcGetString(NULL,ALC_DEFAULT_DEVICE_SPECIFIER);
|
|
const ALCubyte *DSdriver = "DirectSound";
|
|
|
|
if (!strcmp((const ALCbyte *)ALCdriver,"DirectSound3D")) //Alam: OpenAL's DS3D is buggy
|
|
ALCDevice = alcOpenDevice(DSdriver); //Open DirectSound
|
|
else //Alam: The OpenAl device
|
|
ALCDevice = alcOpenDevice(ALCdriver); //Open Default
|
|
#else
|
|
ALCDevice = alcOpenDevice(alcGetString(NULL,ALC_DEFAULT_DEVICE_SPECIFIER));
|
|
#endif
|
|
if (ALCo_GetError() != ALC_NO_ERROR || !ALCDevice)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when opening device!\n", GetALCErrorString(ALCo_Lasterror));
|
|
return inited;
|
|
}
|
|
else
|
|
{
|
|
DBG_Printf("Driver Name : %s\n", alcGetString(ALCDevice,ALC_DEVICE_SPECIFIER));
|
|
DBG_Printf("Extensions : %s\n", alcGetString(ALCDevice,ALC_EXTENSIONS));
|
|
DBG_Printf("S_OpenAl: OpenAl Device %s opened\n",alcGetString(ALCDevice, ALC_DEVICE_SPECIFIER));
|
|
}
|
|
|
|
I_ErrorOpenAl = FatalErrorFunction;
|
|
|
|
AlSetup[1] = snd_dev->sample_rate; //ALC_FREQUENCY
|
|
AlSetup[1] = 44100;
|
|
AlSetup[3] = 35; //ALC_REFRESH
|
|
|
|
//Alam: The Environment?
|
|
ALContext = alcCreateContext(ALCDevice,AlSetup);
|
|
if (ALCo_GetError() != ALC_NO_ERROR || !ALContext)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when making the environment!\n",GetALCErrorString(ALCo_Lasterror));
|
|
return inited;
|
|
}
|
|
else
|
|
{
|
|
DBG_Printf("S_OpenAl: OpenAl environment made\n");
|
|
}
|
|
|
|
alcMakeContextCurrent(ALContext);
|
|
if (ALCo_GetError() != ALC_NO_ERROR)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when setting the environment!\n",GetALCErrorString(ALCo_Lasterror));
|
|
return inited;
|
|
}
|
|
else
|
|
{
|
|
DBG_Printf("S_OpenAl: OpenAl environment setted up\n");
|
|
}
|
|
|
|
DBG_Printf("Vendor : %s\n", alGetString(AL_VENDOR));
|
|
DBG_Printf("Renderer : %s\n", alGetString(AL_RENDERER));
|
|
DBG_Printf("Version : %s\n", alGetString(AL_VERSION));
|
|
DBG_Printf("Extensions : %s\n", alGetString(AL_EXTENSIONS));
|
|
|
|
alDopplerFactor(0.0f);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when setting Doppler Factor!\n",GetALErrorString(ALo_Lasterror));
|
|
return inited;
|
|
}
|
|
else
|
|
{
|
|
DBG_Printf("S_OpenAl: Doppler Factor of %f setted\n", alGetDouble(AL_DOPPLER_FACTOR));
|
|
}
|
|
|
|
alSpeedOfSound(600.0f);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when setting Speed of Sound!\n",GetALErrorString(ALo_Lasterror));
|
|
return inited;
|
|
}
|
|
else
|
|
{
|
|
DBG_Printf("S_OpenAl: Speed of Sound set to %f\n", alGetDouble(AL_SPEED_OF_SOUND));
|
|
}
|
|
|
|
alDistanceModel(model);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when setting Distance Model!\n",GetALErrorString(ALo_Lasterror));
|
|
return inited;
|
|
}
|
|
else
|
|
{
|
|
//DBG_Printf("S_OpenAl: %s mode setted\n",alGetString(model));
|
|
}
|
|
|
|
inited = reallocate_stack();
|
|
|
|
return inited;
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Shutdown 3D Sound
|
|
*
|
|
******************************************************************************/
|
|
EXPORT void HWRAPI( Shutdown ) ( void )
|
|
{
|
|
ALsizei i;
|
|
|
|
DBG_Printf ("S_OpenAL Shutdown()\n");
|
|
|
|
for (i = 0; i < allocated_sounds; i++)
|
|
{
|
|
StopSource(i);
|
|
kill_sound(ALstack + i);
|
|
}
|
|
|
|
#if defined(linux) || defined(__linux) || defined(__linux__)
|
|
alcMakeContextCurrent(NULL);
|
|
//TODO:check?
|
|
#endif
|
|
|
|
if (ALContext)
|
|
{
|
|
alcDestroyContext(ALContext);
|
|
ALContext = NULL;
|
|
}
|
|
|
|
if (ALstack)
|
|
{
|
|
free(ALstack);
|
|
ALstack = NULL;
|
|
}
|
|
|
|
//TODO:check?
|
|
if (ALCDevice)
|
|
{
|
|
alcCloseDevice(ALCDevice);
|
|
ALCDevice = NULL;
|
|
}
|
|
//TODO:check?
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(disable : 4200)
|
|
#pragma pack(1)
|
|
#endif
|
|
|
|
typedef struct
|
|
{
|
|
ALushort header; // 3?
|
|
ALushort samplerate; // 11025+
|
|
ALushort samples; // number of samples
|
|
ALushort dummy; // 0
|
|
ALubyte data[0]; // data;
|
|
} ATTRPACK dssfx_t;
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma pack()
|
|
#pragma warning(default : 4200)
|
|
#endif
|
|
|
|
static ALsizei getfreq(ALvoid *sfxdata, size_t len)
|
|
{
|
|
dssfx_t *dsfx = sfxdata;
|
|
const ALsizei freq = SHORT(dsfx->samplerate);
|
|
|
|
if (len <= 8)
|
|
return 0;
|
|
else
|
|
return freq;
|
|
}
|
|
|
|
static ALsizei makechan(ALuint sfxhandle, ALboolean perm)
|
|
{
|
|
ALsizei chan = find_handle();
|
|
|
|
if (chan == (ALsizei)AL_INVALID) return chan;
|
|
|
|
alGenSources(1, &ALstack[chan].ALsource);
|
|
if (ALo_GetError() != AL_NO_ERROR || !alIsSource(ALstack[chan].ALsource))
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when make an ALSource!\n",GetALErrorString(ALo_Lasterror));
|
|
ALstack[chan].ALsource = (ALuint)AL_INVALID;
|
|
return (ALsizei)AL_INVALID;
|
|
}
|
|
|
|
ALstack[chan].permanent = perm;
|
|
|
|
alSourceQueueBuffers(ALstack[chan].ALsource, 1, &sfxhandle);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when queue up an alSource!\n",GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
return chan;
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Creates ?D source
|
|
*
|
|
******************************************************************************/
|
|
EXPORT INT32 HWRAPI ( AddSource ) (source3D_data_t *src, u_int sfxhandle)
|
|
{
|
|
ALsizei chan = makechan(sfxhandle, (ALboolean)(src?src->permanent:AL_FALSE));
|
|
ALuint sid = (ALuint)AL_INVALID;
|
|
if (chan == (ALsizei)AL_INVALID)
|
|
return AL_INVALID;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
if (src) //3D
|
|
{
|
|
#if 0
|
|
alSourcef(sid, AL_REFERENCE_DISTANCE, src->min_distance);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_REFERENCE_DISTANCE, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alSourcef(sid, AL_MAX_DISTANCE, src->max_distance);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_MAX_DISTANCE, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
#endif
|
|
|
|
if (src->head_relative)
|
|
alSourcei(sid, AL_SOURCE_RELATIVE, AL_TRUE);
|
|
else
|
|
alSourcei(sid, AL_SOURCE_RELATIVE, AL_FALSE);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_SOURCE_RELATIVE, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alSource3f(sid, AL_POSITION, src->pos.x, src->pos.z, src->pos.y);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_POSITION, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
alSource3f(sid, AL_VELOCITY, src->pos.momx, src->pos.momz, src->pos.momy);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_VELOCITY, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
else //2D
|
|
{
|
|
alSourcei(sid, AL_SOURCE_RELATIVE, AL_TRUE);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_SOURCE_RELATIVE, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
alSourcef(sid, AL_ROLLOFF_FACTOR, 0.0f);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_ROLLOFF_FACTOR, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alSourcef(sid, AL_REFERENCE_DISTANCE, 0.0f);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_REFERENCE_DISTANC, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
return chan;
|
|
}
|
|
|
|
EXPORT INT32 HWRAPI ( StartSource ) (INT32 chan)
|
|
{
|
|
ALint state = AL_NONE;
|
|
ALuint sid = (ALuint)AL_INVALID;
|
|
|
|
if (chan <= AL_INVALID || !alIsSource(ALstack[chan].ALsource))
|
|
return AL_FALSE;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
ALo_GetError();
|
|
|
|
alSourcePlay(sid);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alSourcePlay, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alGetSourcei(sid, AL_SOURCE_STATE, &state);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alGetSourcei, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
return (state == AL_PLAYING);
|
|
}
|
|
|
|
EXPORT void HWRAPI ( StopSource) (INT32 chan)
|
|
{
|
|
ALuint sfxhandle = AL_NONE;
|
|
ALuint sid = (ALuint)AL_INVALID;
|
|
if (chan <= AL_INVALID || !alIsSource(ALstack[chan].ALsource))
|
|
return;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
ALo_GetError();
|
|
|
|
#if 1
|
|
alSourceQueueBuffers(sid, 1, &sfxhandle);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alSourceQueueBuffers, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
#else
|
|
alSourceStop(sid);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alSourceStop, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
EXPORT INT32 HWRAPI ( GetHW3DSVersion) (void)
|
|
{
|
|
return VERSION;
|
|
}
|
|
|
|
EXPORT void HWRAPI (BeginFrameUpdate) (void)
|
|
{
|
|
alcSuspendContext(ALContext);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alcSuspendContext, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
EXPORT void HWRAPI (EndFrameUpdate) (void)
|
|
{
|
|
alcProcessContext(ALContext);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alcProcessContext, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
EXPORT INT32 HWRAPI (IsPlaying) (INT32 chan)
|
|
{
|
|
ALint state = AL_NONE;
|
|
ALuint sid = (ALuint)AL_INVALID;
|
|
|
|
if (chan <= AL_INVALID || !alIsSource(ALstack[chan].ALsource))
|
|
return AL_FALSE;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
ALo_GetError();
|
|
|
|
alGetSourcei(sid, AL_SOURCE_STATE, &state);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alGetSourcei, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
return (state == AL_PLAYING);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* UpdateListener
|
|
*
|
|
* Set up main listener properties:
|
|
* - position
|
|
* - orientation
|
|
* - velocity
|
|
*****************************************************************************/
|
|
EXPORT void HWRAPI (UpdateListener) (listener_data_t *data, INT32 num)
|
|
{
|
|
if (num != 1) return;
|
|
|
|
if (data)
|
|
{
|
|
ALfloat facing[6];
|
|
ALdouble f_angle = 0.0;
|
|
if (data->f_angle) f_angle = (ALdouble)((data->f_angle) / 180.0l * M_PIl);
|
|
facing[0] = (ALfloat)cos(f_angle);
|
|
facing[1] = 0.0f;
|
|
facing[2] = (ALfloat)sin(f_angle);
|
|
facing[3] = 0.0f;
|
|
facing[4] = 1.0f;
|
|
facing[5] = 0.0f;
|
|
|
|
alListener3f(AL_POSITION,(ALfloat)-data->x,(ALfloat)data->z,(ALfloat)data->y);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_POSITIO, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alListener3f(AL_VELOCITY,(ALfloat)data->momx,(ALfloat)data->momz,(ALfloat)data->momy);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_VELOCITY, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alListenerfv(AL_ORIENTATION, facing);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_ORIENTATION, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DBG_Printf("Error: 1st listener data is missing\n");
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Update volume for 2D source and separation (panning) of 2D source
|
|
*
|
|
*****************************************************************************/
|
|
EXPORT void HWRAPI (UpdateSourceParms) (INT32 chan, INT32 vol, INT32 sep)
|
|
{
|
|
ALuint sid = AL_NONE;
|
|
ALint is2d = AL_FALSE;
|
|
if (chan > AL_INVALID && !alIsSource(ALstack[chan].ALsource))
|
|
return;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
alGetSourcei(sid, AL_SOURCE_RELATIVE, &is2d);
|
|
|
|
if (!is2d)
|
|
return;
|
|
|
|
if (vol != -1)
|
|
{
|
|
alSourcef(sid,AL_GAIN,ALvol(vol,256));
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alSourcef, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
if (sep != -1)
|
|
{
|
|
ALSetPan(sid,sep-NORMAL_SEP);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: ALSetPan, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Set the global volume for sound effects
|
|
// --------------------------------------------------------------------------
|
|
EXPORT void HWRAPI (SetGlobalSfxVolume) (INT32 vol)
|
|
{
|
|
alListenerf(AL_GAIN, ALvol(vol,32));
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_GAIN, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
//Alam: Not Used?
|
|
EXPORT INT32 HWRAPI (SetCone) (INT32 chan, cone_def_t *cone_def)
|
|
{
|
|
ALuint sid = AL_NONE;
|
|
ALint is2d = AL_FALSE;
|
|
if (chan > AL_INVALID && !alIsSource(ALstack[chan].ALsource))
|
|
return AL_FALSE;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
alGetSourcei(sid, AL_SOURCE_RELATIVE, &is2d);
|
|
|
|
if(is2d || !cone_def)
|
|
return AL_FALSE;
|
|
|
|
alSourcef(sid,AL_CONE_INNER_ANGLE,cone_def->inner);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_CONE_INNER_ANGLE, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alSourcef(sid,AL_CONE_OUTER_ANGLE,cone_def->outer);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_CONE_OUTER_ANGL, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alSourcei(sid,AL_CONE_OUTER_GAIN, cone_def->outer_gain);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_CONE_OUTER_GAIN, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
return AL_TRUE;
|
|
}
|
|
|
|
EXPORT void HWRAPI (Update3DSource) (INT32 chan, source3D_pos_t *sfx)
|
|
{
|
|
ALuint sid = AL_NONE;
|
|
ALint is2d = AL_FALSE;
|
|
if (chan > AL_INVALID && !alIsSource(ALstack[chan].ALsource))
|
|
return;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
alGetSourcei(sid, AL_SOURCE_RELATIVE, &is2d);
|
|
|
|
if (is2d)
|
|
return;
|
|
|
|
alSource3f(sid, AL_POSITION, sfx->x, sfx->z, sfx->y);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_POSITION, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
alSource3f(sid, AL_VELOCITY, sfx->momx, sfx->momz, sfx->momy);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: AL_VELOCITY, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
// Load new sound data into source
|
|
//-------------------------------------------------------------
|
|
EXPORT INT32 HWRAPI (ReloadSource) (INT32 chan, u_int sfxhandle)
|
|
{
|
|
ALuint sid;
|
|
|
|
if (chan <= AL_INVALID || !alIsSource(ALstack[chan].ALsource) || !alIsBuffer(sfxhandle))
|
|
return AL_INVALID;
|
|
else
|
|
sid = ALstack[chan].ALsource;
|
|
|
|
ALo_GetError();
|
|
|
|
alSourceQueueBuffers(sid, 1, &sfxhandle);
|
|
if (ALo_GetError() == AL_INVALID_OPERATION) //Alam: not needed?
|
|
{
|
|
alSourceStop(sid);
|
|
alSourcei(sid, AL_BUFFER, sfxhandle);
|
|
ALo_GetError();
|
|
}
|
|
if (ALo_Lasterror != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alSourcei, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
return chan;
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Destroy source and remove it from stack if it is a 2D source.
|
|
* Otherwise put source into cache
|
|
*
|
|
*****************************************************************************/
|
|
EXPORT void HWRAPI (KillSource) (INT32 chan)
|
|
{
|
|
if (chan > AL_INVALID && (ALsizei)chan <= allocated_sounds)
|
|
kill_sound(ALstack + chan);
|
|
}
|
|
|
|
EXPORT u_int HWRAPI (AddSfx) (sfx_data_t *sfx)
|
|
{
|
|
ALuint chan = (ALuint)AL_INVALID;
|
|
ALsizei freq = 11025;
|
|
ALubyte *data = NULL;
|
|
ALsizei size = 0;
|
|
|
|
if (!sfx)
|
|
return 0;
|
|
else
|
|
{
|
|
data = ((ALubyte *)sfx->data)+8;
|
|
size = (ALsizei)(sfx->length-8);
|
|
}
|
|
|
|
alGenBuffers(1, &chan);
|
|
if (ALo_GetError() != AL_NO_ERROR || !alIsBuffer(chan))
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when make an ALBuffer!\n",GetALErrorString(ALo_Lasterror));
|
|
return (u_int)AL_INVALID;
|
|
}
|
|
|
|
freq = getfreq(sfx->data, sfx->length);
|
|
|
|
alBufferData(chan, AL_FORMAT_MONO8, data, size, freq);
|
|
if (ALo_GetError() != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("S_OpenAl: Error %s when setting up a alBuffer!\n",GetALErrorString(ALo_Lasterror));
|
|
}
|
|
|
|
return chan;
|
|
}
|
|
|
|
EXPORT void HWRAPI (KillSfx) (u_int sfxhandle)
|
|
{
|
|
ALuint ALsfx = sfxhandle;
|
|
if (!alIsBuffer(ALsfx))
|
|
return;
|
|
alDeleteBuffers(1, &ALsfx);
|
|
if (ALo_GetError() == AL_INVALID_OPERATION)
|
|
{
|
|
// Buffer leak
|
|
}
|
|
else if (ALo_Lasterror != AL_NO_ERROR)
|
|
{
|
|
DBG_Printf("%s: alDeleteBuffers, %s", __FUNCTION__, GetALErrorString(ALo_Lasterror));
|
|
}
|
|
}
|
|
|
|
EXPORT void HWRAPI (GetHW3DSTitle) (char *buf, size_t size)
|
|
{
|
|
strncpy(buf, "OpenAL", size);
|
|
}
|
|
|
|
|
|
#ifdef _WINDOWS
|
|
BOOL WINAPI DllMain(HINSTANCE hinstDLL, // handle to DLL module
|
|
DWORD fdwReason, // reason for calling function
|
|
LPVOID lpvReserved) // reserved
|
|
{
|
|
// Perform actions based on the reason for calling.
|
|
UNREFERENCED_PARAMETER(lpvReserved);
|
|
switch ( fdwReason )
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
// Initialize once for each new process.
|
|
// Return FALSE to fail DLL load.
|
|
#ifdef DEBUG_TO_FILE
|
|
logstream = fopen("s_openal.log", "wt");
|
|
if (logstream == NULL)
|
|
return FALSE;
|
|
#endif
|
|
DisableThreadLibraryCalls(hinstDLL);
|
|
break;
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
// Do thread-specific initialization.
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
// Do thread-specific cleanup.
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
// Perform any necessary cleanup.
|
|
#ifdef DEBUG_TO_FILE
|
|
if ( logstream)
|
|
{
|
|
fclose(logstream);
|
|
logstream = NULL;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
return TRUE; // Successful DLL_PROCESS_ATTACH.
|
|
}
|
|
#elif !defined (_WINDOWS)
|
|
|
|
// **************************************************************************
|
|
// FUNCTIONS
|
|
// **************************************************************************
|
|
|
|
EXPORT void _init()
|
|
{
|
|
#ifdef DEBUG_TO_FILE
|
|
logstream = fopen("s_openal.log", "w+");
|
|
#endif
|
|
}
|
|
|
|
EXPORT void _fini()
|
|
{
|
|
#ifdef DEBUG_TO_FILE
|
|
if (logstream)
|
|
fclose(logstream);
|
|
logstream = NULL;
|
|
#endif
|
|
}
|
|
#endif
|
|
|