RP412/MUNGA_L4/L4AUDEFX.cpp

//###########################################################################
//
//	L4AUDEFX.cpp -- OpenAL EFX bridge (docs/SOUND.md, findings F9 and F11).
//	See L4AUDEFX.h for the fidelity rationale.
//
//###########################################################################
#include "mungal4.h"
#pragma hdrstop

#include "l4audefx.h"
#include "openal/alc.h"
#include "openal/efx.h"

#ifndef AL_EFFECT_EAXREVERB
#define AL_EFFECT_EAXREVERB 0x8000	// newer efx.h constant; OpenAL Soft supports it
#endif

namespace
{
	bool s_available = false;
	ALuint s_reverbSlot = 0;
	ALuint s_reverbEffect = 0;
	ALuint s_scratchFilter = 0;

	LPALGENEFFECTS               p_alGenEffects = 0;
	LPALEFFECTI                  p_alEffecti = 0;
	LPALEFFECTF                  p_alEffectf = 0;
	LPALGENAUXILIARYEFFECTSLOTS  p_alGenAuxiliaryEffectSlots = 0;
	LPALAUXILIARYEFFECTSLOTI     p_alAuxiliaryEffectSloti = 0;
	LPALAUXILIARYEFFECTSLOTF     p_alAuxiliaryEffectSlotf = 0;
	LPALGENFILTERS               p_alGenFilters = 0;
	LPALFILTERI                  p_alFilteri = 0;
	LPALFILTERF                  p_alFilterf = 0;
}

bool EFX_Available()
{
	return s_available;
}

bool EFX_Initialize(float global_reverb_scale)
{
	ALCcontext *context = alcGetCurrentContext();
	if (context == 0)
	{
		return false;
	}
	ALCdevice *device = alcGetContextsDevice(context);
	if (device == 0 || !alcIsExtensionPresent(device, "ALC_EXT_EFX"))
	{
		Tell("L4AUDEFX: ALC_EXT_EFX not present - filters and reverb inert\n");
		return false;
	}

	p_alGenEffects              = (LPALGENEFFECTS)alGetProcAddress("alGenEffects");
	p_alEffecti                 = (LPALEFFECTI)alGetProcAddress("alEffecti");
	p_alEffectf                 = (LPALEFFECTF)alGetProcAddress("alEffectf");
	p_alGenAuxiliaryEffectSlots = (LPALGENAUXILIARYEFFECTSLOTS)alGetProcAddress("alGenAuxiliaryEffectSlots");
	p_alAuxiliaryEffectSloti    = (LPALAUXILIARYEFFECTSLOTI)alGetProcAddress("alAuxiliaryEffectSloti");
	p_alAuxiliaryEffectSlotf    = (LPALAUXILIARYEFFECTSLOTF)alGetProcAddress("alAuxiliaryEffectSlotf");
	p_alGenFilters              = (LPALGENFILTERS)alGetProcAddress("alGenFilters");
	p_alFilteri                 = (LPALFILTERI)alGetProcAddress("alFilteri");
	p_alFilterf                 = (LPALFILTERF)alGetProcAddress("alFilterf");

	if (!p_alGenEffects || !p_alEffecti || !p_alEffectf
		|| !p_alGenAuxiliaryEffectSlots || !p_alAuxiliaryEffectSloti || !p_alAuxiliaryEffectSlotf
		|| !p_alGenFilters || !p_alFilteri || !p_alFilterf)
	{
		Tell("L4AUDEFX: EFX entry points missing - filters and reverb inert\n");
		return false;
	}

	alGetError();
	p_alGenAuxiliaryEffectSlots(1, &s_reverbSlot);
	p_alGenEffects(1, &s_reverbEffect);
	if (alGetError() != AL_NO_ERROR)
	{
		return false;
	}

	//
	// EAXReverb where available (OpenAL Soft: yes), plain reverb otherwise.
	//
	p_alEffecti(s_reverbEffect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
	if (alGetError() != AL_NO_ERROR)
	{
		p_alEffecti(s_reverbEffect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
	}
	p_alAuxiliaryEffectSloti(s_reverbSlot, AL_EFFECTSLOT_EFFECT, (ALint)s_reverbEffect);

	//
	// The authentic wet level: the original sent CC91 = global_reverb_scale on
	// every 3D channel, so one global slot gain reproduces the same uniform
	// send.  RP authors 0.35 (AUDIO.INI); BT used 0.3.
	//
	p_alAuxiliaryEffectSlotf(s_reverbSlot, AL_EFFECTSLOT_GAIN,
		(global_reverb_scale < 0.0f) ? 0.0f :
		(global_reverb_scale > 1.0f) ? 1.0f : global_reverb_scale);

	//
	// LOWPASS only, deliberately.  A bandpass would have been convenient -- one
	// direct filter carrying both the authored brightness model and a bass trim
	// -- but the OpenAL this game ships (Creative's, via oalinst.exe; renderer
	// reports "Generic Software") implements ONLY AL_FILTER_LOWPASS.  It rejects
	// both HIGHPASS and BANDPASS, verified on the build machine.  Asking for one
	// leaves an error pending, which the check below would read as total EFX
	// failure and silently take the reverb down with it.
	//
	p_alGenFilters(1, &s_scratchFilter);
	p_alFilteri(s_scratchFilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);

	if (alGetError() != AL_NO_ERROR)
	{
		//
		// No usable direct filter.  The reverb slot above is independent of it,
		// so keep the bridge alive and just make the filter path a no-op rather
		// than losing F11 as well.
		//
		s_scratchFilter = 0;
		Tell("L4AUDEFX: no lowpass filter available - brightness path inert\n");
	}

	s_available = (alGetError() == AL_NO_ERROR);
	Tell("L4AUDEFX: " << (s_available ? "ready" : "failed")
		<< " (reverb slot gain " << global_reverb_scale << ")\n");
	return s_available;
}

void EFX_SetSourceLowpassGainHF(ALuint source, float gainhf)
{
	if (!s_available || s_scratchFilter == 0)
	{
		return;
	}
	if (gainhf < 0.001f) gainhf = 0.001f;
	if (gainhf > 1.0f)   gainhf = 1.0f;

	//
	// Nothing to do at unity -- detach rather than attach a filter that would
	// only cost mixing work to achieve nothing.
	//
	if (gainhf >= 0.999f)
	{
		alSourcei(source, AL_DIRECT_FILTER, AL_FILTER_NULL);
		alGetError();
		return;
	}

	//
	// Filter parameters are COPIED at attach time, so one scratch filter object
	// serves every source -- no per-source filter allocation is needed.
	//
	p_alFilterf(s_scratchFilter, AL_LOWPASS_GAIN, 1.0f);
	p_alFilterf(s_scratchFilter, AL_LOWPASS_GAINHF, gainhf);
	alSourcei(source, AL_DIRECT_FILTER, (ALint)s_scratchFilter);
	alGetError();
}

void EFX_AttachReverbSend(ALuint source)
{
	if (!s_available)
	{
		return;
	}
	alSource3i(source, AL_AUXILIARY_SEND_FILTER, (ALint)s_reverbSlot, 0, AL_FILTER_NULL);
}

void EFX_ClearSourceEffects(ALuint source)
{
	if (!s_available)
	{
		return;
	}
	alSourcei(source, AL_DIRECT_FILTER, AL_FILTER_NULL);
	alSource3i(source, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, 0, AL_FILTER_NULL);
	alGetError();								// swallow any property complaint
}