snd_main.c File Reference

#include "quakedef.h"
#include "snd_main.h"
#include "snd_ogg.h"
#include "csprogs.h"
#include "cl_collision.h"
#include "cdaudio.h"

Include dependency graph for snd_main.c:

Go to the source code of this file.

Macros
#define	SND_MAX_CHANNELS   8
#define	SND_MAX_SPEED   192000
#define	SND_MAX_WIDTH   2
#define	SND_MIN_CHANNELS   1
#define	SND_MIN_SPEED   8000
#define	SND_MIN_WIDTH   1
#define	SND_SPEAKERLAYOUTS   (sizeof(snd_speakerlayouts) / sizeof(snd_speakerlayouts[0]))
#define	SWAP_LISTENERS(l1, l2, tmpl)

Enumerations
enum	spatialmethod_t { SPATIAL_NONE , SPATIAL_LOG , SPATIAL_POW , SPATIAL_THRESH }

Functions
void	S_ClearUsed (void)
sfx_t *	S_FindName (const char *name)
void	S_FreeSfx (sfx_t *sfx, qbool force)
float	S_GetChannelPosition (unsigned int ch_ind)
float	S_GetEntChannelPosition (int entnum, int entchannel)
int	S_GetSoundChannels (void)
int	S_GetSoundRate (void)
int	S_GetSoundWidth (void)
void	S_Init (void)
qbool	S_IsSoundPrecached (const sfx_t *sfx)
qbool	S_LocalSound (const char *sound)
qbool	S_LocalSoundEx (const char *sound, int chan, float fvol)
static void	S_PaintAndSubmit (void)
void	S_PauseGameSounds (qbool toggle)
static void	S_PauseSound_f (cmd_state_t *cmd)
static void	S_Play2_f (cmd_state_t *cmd)
static void	S_Play_Common (cmd_state_t *cmd, float fvol, float attenuation)
static void	S_Play_f (cmd_state_t *cmd)
static void	S_PlaySfxOnChannel (sfx_t *sfx, channel_t *target_chan, unsigned int flags, vec3_t origin, float fvol, float attenuation, qbool isstatic, int entnum, int entchannel, int startpos, float fspeed)
static void	S_PlayVol_f (cmd_state_t *cmd)
sfx_t *	S_PrecacheSound (const char *name, qbool complain, qbool levelsound)
void	S_PurgeUnused (void)
static void	S_Restart_f (cmd_state_t *cmd)
qbool	S_SetChannelFlag (unsigned int ch_ind, unsigned int flag, qbool value)
static void	S_SetChannelLayout (void)
void	S_SetChannelSpeed (unsigned int ch_ind, float fspeed)
void	S_SetChannelVolume (unsigned int ch_ind, float fvol)
void	S_Shutdown (void)
static void	S_SoundInfo_f (cmd_state_t *cmd)
float	S_SoundLength (const char *name)
static void	S_SoundList_f (cmd_state_t *cmd)
int	S_StartSound (int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol, float attenuation)
	S_StartSound returns the channel index, or -1 if an error occurred.
int	S_StartSound_StartPosition_Flags (int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float fvol, float attenuation, float startposition, int flags, float fspeed)
void	S_Startup (void)
void	S_StaticSound (sfx_t *sfx, vec3_t origin, float fvol, float attenuation)
void	S_StopAllSounds (void)
void	S_StopAllSounds_f (cmd_state_t *cmd)
void	S_StopChannel (unsigned int channel_ind, qbool lockmutex, qbool freesfx)
void	S_StopSound (int entnum, int entchannel)
void	S_Terminate (void)
void	S_UnloadAllSounds_f (cmd_state_t *cmd)
void	S_Update (const matrix4x4_t *listenermatrix)
static void	S_UpdateAmbientSounds (void)
static channel_t *	SND_PickChannel (int entnum, int entchannel)
static void	SND_Spatialize (channel_t *ch, qbool isstatic)
static void	SND_Spatialize_WithSfx (channel_t *ch, qbool isstatic, sfx_t *sfx)

Variables
cvar_t	_snd_mixahead = {CF_CLIENT | CF_ARCHIVE, "_snd_mixahead", "0.15", "how much sound to mix ahead of time"}
static cvar_t	ambient_fade = {CF_CLIENT, "ambient_fade", "100", "rate of volume fading when moving from one environment to another"}
static cvar_t	ambient_level = {CF_CLIENT, "ambient_level", "0.3", "volume of environment noises (water and wind)"}
static const char *	ambient_names [2] = { "sound/ambience/water1.wav", "sound/ambience/wind2.wav" }
static sfx_t *	ambient_sfxs [2] = { NULL, NULL }
cvar_t	bgmvolume = {CF_CLIENT | CF_ARCHIVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"}
sfx_t	changevolume_sfx = {""}
channel_t	channels [MAX_CHANNELS]
cvar_t	cl_gameplayfix_soundsmovewithentities
static int	current_channellayout = SND_CHANNELLAYOUT_AUTO
static int	current_channellayout_used = SND_CHANNELLAYOUT_AUTO
static bool	current_swapstereo = false
static unsigned int	extrasoundtime = 0
static sfx_t *	known_sfx = NULL
matrix4x4_t	listener_basematrix
matrix4x4_t	listener_matrix [SND_LISTENERS]
vec3_t	listener_origin
static unsigned char *	listener_pvs = NULL
static int	listener_pvsbytes = 0
cvar_t	mastervolume = {CF_CLIENT | CF_ARCHIVE, "mastervolume", "0.7", "master volume"}
static cvar_t	nosound = {CF_CLIENT, "nosound", "0", "disables sound"}
static unsigned int	oldpaintedtime = 0
qbool	simsound = false
	If simsound is true, the sound card is not initialized and no sound is submitted to it.
cvar_t	snd_attenuation_decibel = {CF_CLIENT | CF_ARCHIVE, "snd_attenuation_decibel", "0", "Decibel sound attenuation per sound radius distance"}
cvar_t	snd_attenuation_exponent = {CF_CLIENT | CF_ARCHIVE, "snd_attenuation_exponent", "1", "Exponent of (1-radius) in sound attenuation formula"}
bool	snd_blocked = false
	When true, we submit silence to the audio device.
cvar_t	snd_bufferlength = {CF_CLIENT | CF_ARCHIVE, "snd_bufferlength", "20", "Desired length of the SDL2 audio buffer in milliseconds, smaller values reduce latency but can lead to underflow if the system is heavily loaded. Affects only how many sample frames are requested (which will be a power of 2 between 512 and 8192 inclusive)"}
cvar_t	snd_channel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel0volume", "1", "volume multiplier of the auto-allocate entity channel"}
cvar_t	snd_channel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel1volume", "1", "volume multiplier of the 1st entity channel"}
cvar_t	snd_channel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel2volume", "1", "volume multiplier of the 2nd entity channel"}
cvar_t	snd_channel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel3volume", "1", "volume multiplier of the 3rd entity channel"}
cvar_t	snd_channel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel4volume", "1", "volume multiplier of the 4th entity channel"}
cvar_t	snd_channel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel5volume", "1", "volume multiplier of the 5th entity channel"}
cvar_t	snd_channel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel6volume", "1", "volume multiplier of the 6th entity channel"}
cvar_t	snd_channel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel7volume", "1", "volume multiplier of the 7th entity channel"}
cvar_t	snd_channellayout = {CF_CLIENT, "snd_channellayout", "0", "channel layout. Can be 0 (auto - snd_restart needed), 1 (standard layout), or 2 (ALSA layout)"}
static cvar_t	snd_channels = {CF_CLIENT | CF_ARCHIVE, "snd_channels", "2", "number of channels for the sound output (2 for stereo; up to 8 supported for 3D sound)"}
cvar_t	snd_csqcchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel0volume", "1", "volume multiplier of the auto-allocate entity channel CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel1volume", "1", "volume multiplier of the 1st entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel2volume", "1", "volume multiplier of the 2nd entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel3volume", "1", "volume multiplier of the 3rd entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel4volume", "1", "volume multiplier of the 4th entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel5volume", "1", "volume multiplier of the 5th entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel6volume", "1", "volume multiplier of the 6th entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_csqcchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel7volume", "1", "volume multiplier of the 7th entity channel of CSQC entities (DEPRECATED)"}
cvar_t	snd_entchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel1volume", "1", "volume multiplier of the 1st entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel2volume", "1", "volume multiplier of the 2nd entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel3volume", "1", "volume multiplier of the 3rd entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel4volume", "1", "volume multiplier of the 4th entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel5volume", "1", "volume multiplier of the 5th entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel6volume", "1", "volume multiplier of the 6th entity channel of regular entities (DEPRECATED)"}
cvar_t	snd_entchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel7volume", "1", "volume multiplier of the 7th entity channel of regular entities (DEPRECATED)"}
static cvar_t	snd_identicalsoundrandomization_tics = {CF_CLIENT, "snd_identicalsoundrandomization_tics", "0", "if nonzero, how many tics to limit sound randomization as defined by snd_identicalsoundrandomization_time"}
static cvar_t	snd_identicalsoundrandomization_time = {CF_CLIENT, "snd_identicalsoundrandomization_time", "0.1", "how much seconds to randomly skip (positive) or delay (negative) sounds when multiple identical sounds are started on the same frame"}
cvar_t	snd_initialized = {CF_CLIENT | CF_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"}
cvar_t	snd_maxchannelvolume = {CF_CLIENT | CF_ARCHIVE, "snd_maxchannelvolume", "10", "maximum volume of a single sound"}
mempool_t *	snd_mempool
cvar_t	snd_mutewhenidle = {CF_CLIENT | CF_ARCHIVE, "snd_mutewhenidle", "1", "1 disables sound output when game window is inactive, 2 disables it only when the window is minimised"}
cvar_t	snd_playerchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel1volume", "1", "volume multiplier of the 1st entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel2volume", "1", "volume multiplier of the 2nd entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel3volume", "1", "volume multiplier of the 3rd entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel4volume", "1", "volume multiplier of the 4th entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel5volume", "1", "volume multiplier of the 5th entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel6volume", "1", "volume multiplier of the 6th entity channel of player entities (DEPRECATED)"}
cvar_t	snd_playerchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel7volume", "1", "volume multiplier of the 7th entity channel of player entities (DEPRECATED)"}
static cvar_t	snd_precache = {CF_CLIENT, "snd_precache", "1", "loads sounds before they are used"}
snd_ringbuffer_t *	snd_renderbuffer = NULL
static cvar_t	snd_show = {CF_CLIENT, "snd_show", "0", "shows some statistics about sound mixing"}
cvar_t	snd_softclip = {CF_CLIENT | CF_ARCHIVE, "snd_softclip", "0", "Use soft-clipping. Soft-clipping can make the sound more smooth if very high volume levels are used. Enable this option if the dynamic range of the loudspeakers is very low. WARNING: This feature creates distortion and should be considered a last resort."}
cvar_t	snd_soundradius = {CF_CLIENT | CF_ARCHIVE, "snd_soundradius", "1200", "radius of weapon sounds and other standard sound effects (monster idle noises are half this radius and flickering light noises are one third of this radius)"}
cvar_t	snd_spatialization_control = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_control", "0", "enable spatialization control (headphone friendly mode)"}
cvar_t	snd_spatialization_max = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max", "0.95", "maximum spatialization of sounds"}
cvar_t	snd_spatialization_max_radius = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max_radius", "100", "use maximum spatialization below this radius"}
cvar_t	snd_spatialization_min = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min", "0.70", "minimum spatializazion of sounds"}
cvar_t	snd_spatialization_min_radius = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min_radius", "10000", "use minimum spatialization above to this radius"}
cvar_t	snd_spatialization_occlusion = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_occlusion", "1", "enable occlusion testing on spatialized sounds, which simply quiets sounds that are blocked by the world; 1 enables PVS method, 2 enables LineOfSight method, 3 enables both"}
cvar_t	snd_spatialization_power = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_power", "0", "exponent of the spatialization falloff curve (0: logarithmic)"}
cvar_t	snd_spatialization_prologic = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic", "0", "use dolby prologic (I, II or IIx) encoding (snd_channels must be 2)"}
cvar_t	snd_spatialization_prologic_frontangle = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic_frontangle", "30", "the angle between the front speakers and the center speaker"}
speakerlayout_t	snd_speakerlayout
static const speakerlayout_t	snd_speakerlayouts []
static cvar_t	snd_speed = {CF_CLIENT | CF_ARCHIVE, "snd_speed", "48000", "sound output frequency, in hertz"}
static cvar_t	snd_startloopingsounds = {CF_CLIENT, "snd_startloopingsounds", "1", "whether to start sounds that would loop (you want this to be 1); existing sounds are not affected"}
static cvar_t	snd_startnonloopingsounds = {CF_CLIENT, "snd_startnonloopingsounds", "1", "whether to start sounds that would not loop (you want this to be 1); existing sounds are not affected"}
static double	snd_starttime = 0.0
cvar_t	snd_staticvolume = {CF_CLIENT | CF_ARCHIVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"}
cvar_t	snd_streaming = {CF_CLIENT | CF_ARCHIVE, "snd_streaming", "1", "enables keeping compressed ogg sound files compressed, decompressing them only as needed, otherwise they will be decompressed completely at load (may use a lot of memory); when set to 2, streaming is performed even if this would waste memory"}
cvar_t	snd_streaming_length = {CF_CLIENT | CF_ARCHIVE, "snd_streaming_length", "1", "decompress sounds completely if they are less than this play time when snd_streaming is 1"}
cvar_t	snd_swapstereo = {CF_CLIENT | CF_ARCHIVE, "snd_swapstereo", "0", "swaps left/right speakers for old ISA soundblaster cards"}
qbool	snd_threaded = false
	enables use of snd_usethreadedmixing, provided that no sound hacks are in effect (like timedemo)
qbool	snd_usethreadedmixing = false
	if true, the main thread does not mix sound, soundtime does not advance, and neither does snd_renderbuffer->endframe, instead the audio thread will call S_MixToBuffer as needed
cvar_t	snd_waterfx = {CF_CLIENT | CF_ARCHIVE, "snd_waterfx", "1", "underwater sound filter strength"}
static cvar_t	snd_width = {CF_CLIENT | CF_ARCHIVE, "snd_width", "4", "sound output precision, in bytes - 1 = 8bit, 2 = 16bit, 4 = 32bit float"}
cvar_t	snd_worldchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel1volume", "1", "volume multiplier of the 1st entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel2volume", "1", "volume multiplier of the 2nd entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel3volume", "1", "volume multiplier of the 3rd entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel4volume", "1", "volume multiplier of the 4th entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel5volume", "1", "volume multiplier of the 5th entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel6volume", "1", "volume multiplier of the 6th entity channel of the world entity (DEPRECATED)"}
cvar_t	snd_worldchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel7volume", "1", "volume multiplier of the 7th entity channel of the world entity (DEPRECATED)"}
static unsigned int	soundtime = 0
static float	spatialdiff
static float	spatialfactor
spatialmethod_t	spatialmethod
static float	spatialmin
static float	spatialoffset
static float	spatialpower
unsigned int	total_channels
cvar_t	v_flipped
cvar_t	volume = {CF_CLIENT | CF_ARCHIVE, "volume", "0.7", "volume of sound effects"}

Macro Definition Documentation

SND_MAX_CHANNELS

#define SND_MAX_CHANNELS   8

Definition at line 39 of file snd_main.c.

Referenced by S_Startup().

SND_MAX_SPEED

#define SND_MAX_SPEED   192000

Definition at line 35 of file snd_main.c.

Referenced by S_Startup().

SND_MAX_WIDTH

#define SND_MAX_WIDTH   2

Definition at line 37 of file snd_main.c.

Referenced by S_Startup().

SND_MIN_CHANNELS

#define SND_MIN_CHANNELS   1

Definition at line 38 of file snd_main.c.

Referenced by S_Startup().

SND_MIN_SPEED

#define SND_MIN_SPEED   8000

Definition at line 34 of file snd_main.c.

Referenced by S_Startup().

SND_MIN_WIDTH

#define SND_MIN_WIDTH   1

Definition at line 36 of file snd_main.c.

Referenced by S_Startup().

SND_SPEAKERLAYOUTS

#define SND_SPEAKERLAYOUTS   (sizeof(snd_speakerlayouts) / sizeof(snd_speakerlayouts[0]))

Definition at line 49 of file snd_main.c.

Referenced by S_SetChannelLayout().

SWAP_LISTENERS

#define SWAP_LISTENERS	(		l1,
			l2,
			tmpl )

Value:

{ tmpl = (l1); (l1) = (l2); (l2) = tmpl; }

Definition at line 393 of file snd_main.c.

Referenced by S_SetChannelLayout().

Enumeration Type Documentation

spatialmethod_t

enum spatialmethod_t

Enumerator
SPATIAL_NONE
SPATIAL_LOG
SPATIAL_POW
SPATIAL_THRESH

Definition at line 161 of file snd_main.c.

{ SPATIAL_NONE, SPATIAL_LOG, SPATIAL_POW, SPATIAL_THRESH } spatialmethod_t;

Function Documentation

S_ClearUsed()

void S_ClearUsed

(

void

)

Definition at line 996 of file snd_main.c.

{
    sfx_t *sfx;
//  sfx_t *sfxnext;
    unsigned int i;
 
    // Start the ambient sounds and make them loop
    for (i = 0; i < sizeof (ambient_sfxs) / sizeof (ambient_sfxs[0]); i++)
    {
        // Precache it if it's not done (and pass false for levelsound because these are permanent)
        if (ambient_sfxs[i] == NULL)
            ambient_sfxs[i] = S_PrecacheSound (ambient_names[i], false, false);
        if (ambient_sfxs[i] != NULL)
        {
            channels[i].sfx = ambient_sfxs[i];
            channels[i].sfx->flags |= SFXFLAG_MENUSOUND;
            channels[i].flags |= CHANNELFLAG_FORCELOOP;
            channels[i].basevolume = 0.0f;
            channels[i].basespeed = channels[i].mixspeed = 1.0f;
        }
    }
 
    // Clear SFXFLAG_LEVELSOUND flag so that sounds not precached this level will be purged
    for (sfx = known_sfx; sfx != NULL; sfx = sfx->next)
        sfx->flags &= ~SFXFLAG_LEVELSOUND;
}

References ambient_names, ambient_sfxs, channel_t::basespeed, channel_t::basevolume, CHANNELFLAG_FORCELOOP, channels, channel_t::flags, sfx_t::flags, i, known_sfx, channel_t::mixspeed, NULL, S_PrecacheSound(), channel_t::sfx, SFXFLAG_LEVELSOUND, and SFXFLAG_MENUSOUND.

Referenced by CL_ParseServerInfo(), and QW_CL_RequestNextDownload().

S_FindName()

sfx_t * S_FindName

(

const char *

name

)

Definition at line 895 of file snd_main.c.

{
    sfx_t *sfx;
 
    if (!snd_initialized.integer)
        return NULL;
 
    if(!strcmp(name, changevolume_sfx.name))
        return &changevolume_sfx;
 
    if (strlen (name) >= sizeof (sfx->name))
    {
        Con_Printf ("S_FindName: sound name too long (%s)\n", name);
        return NULL;
    }
 
    // Look for this sound in the list of known sfx
    // TODO: hash table search?
    for (sfx = known_sfx; sfx != NULL; sfx = sfx->next)
        if(!strcmp (sfx->name, name))
            return sfx;
 
    // check for # in the beginning, try lookup by soundindex
    if (name[0] == '#' && name[1])
    {
        int soundindex = atoi(name + 1);
        if (soundindex > 0 && soundindex < MAX_SOUNDS)
            if (cl.sound_precache[soundindex]->name[0])
                return cl.sound_precache[soundindex];
    }
 
    // Add a sfx_t struct for this sound
    sfx = (sfx_t *)Mem_Alloc (snd_mempool, sizeof (*sfx));
    memset (sfx, 0, sizeof(*sfx));
    dp_strlcpy (sfx->name, name, sizeof (sfx->name));
    sfx->memsize = sizeof(*sfx);
    sfx->next = known_sfx;
    known_sfx = sfx;
 
    return sfx;
}

References changevolume_sfx, cl, Con_Printf(), dp_strlcpy, cvar_t::integer, known_sfx, MAX_SOUNDS, Mem_Alloc, name, sfx_t::name, NULL, snd_initialized, snd_mempool, client_state_t::sound_precache, and strlen().

Referenced by S_PrecacheSound(), S_SoundLength(), VM_CL_ambientsound(), VM_CL_pointsound(), and VM_CL_sound().

S_FreeSfx()

void S_FreeSfx	(	sfx_t *	sfx,
		qbool	force )

Definition at line 943 of file snd_main.c.

{
    unsigned int i;
 
    // Do not free a precached sound during purge
    if (!force && (sfx->flags & (SFXFLAG_LEVELSOUND | SFXFLAG_MENUSOUND)))
        return;
 
    if (developer_loading.integer)
        Con_Printf ("unloading sound %s\n", sfx->name);
 
    // Remove it from the list of known sfx
    if (sfx == known_sfx)
        known_sfx = known_sfx->next;
    else
    {
        sfx_t *prev_sfx;
 
        for (prev_sfx = known_sfx; prev_sfx != NULL; prev_sfx = prev_sfx->next)
            if (prev_sfx->next == sfx)
            {
                prev_sfx->next = sfx->next;
                break;
            }
        if (prev_sfx == NULL)
        {
            Con_Printf ("S_FreeSfx: Can't find SFX %s in the list!\n", sfx->name);
            return;
        }
    }
 
    // Stop all channels using this sfx
    for (i = 0; i < total_channels; i++)
    {
        if (channels[i].sfx == sfx)
        {
            Con_Printf("S_FreeSfx: stopping channel %i for sfx \"%s\"\n", i, sfx->name);
            S_StopChannel (i, true, false);
        }
    }
 
    // Free it
    if (sfx->fetcher != NULL && sfx->fetcher->freesfx != NULL)
        sfx->fetcher->freesfx(sfx);
    Mem_Free (sfx);
}

References channels, Con_Printf(), developer_loading, i, cvar_t::integer, known_sfx, Mem_Free, NULL, S_StopChannel(), SFXFLAG_LEVELSOUND, SFXFLAG_MENUSOUND, and total_channels.

Referenced by S_Play_Common(), S_PurgeUnused(), S_StopChannel(), S_Terminate(), and S_UnloadAllSounds_f().

S_GetChannelPosition()

float S_GetChannelPosition

(

unsigned int

ch_ind

)

Definition at line 1773 of file snd_main.c.

{
    // note: this is NOT accurate yet
    double s;
    channel_t *ch = &channels[ch_ind];
    sfx_t *sfx = ch->sfx;
    if (!sfx)
        return -1;
 
    s = ch->position / sfx->format.speed;
    /*
    if(!snd_usethreadedmixing)
        s += _snd_mixahead.value;
    */
    return (float)s;
}

References channels, channel_t::position, and channel_t::sfx.

Referenced by CDAudio_GetPosition(), and S_GetEntChannelPosition().

S_GetEntChannelPosition()

float S_GetEntChannelPosition	(	int	entnum,
		int	entchannel )

Definition at line 1790 of file snd_main.c.

{
    channel_t *ch;
    unsigned int i;
 
    for (i = 0; i < total_channels; i++)
    {
        ch = &channels[i];
        if (ch->entnum == entnum && ch->entchannel == entchannel)
            return S_GetChannelPosition(i);
    }
    return -1; // no playing sound in this channel
}

References channels, channel_t::entchannel, channel_t::entnum, entnum, i, S_GetChannelPosition(), and total_channels.

Referenced by VM_getsoundtime().

S_GetSoundChannels()

int S_GetSoundChannels

(

void

)

Definition at line 382 of file snd_main.c.

{
    return snd_renderbuffer ? snd_renderbuffer->format.channels : 0;
}

References snd_format_t::channels, snd_ringbuffer_t::format, and snd_renderbuffer.

Referenced by XMP_LoadModFile().

S_GetSoundRate()

int S_GetSoundRate

(

void

)

Definition at line 377 of file snd_main.c.

{
    return snd_renderbuffer ? snd_renderbuffer->format.speed : 0;
}

References snd_ringbuffer_t::format, snd_renderbuffer, and snd_format_t::speed.

Referenced by S_SoundLength(), and XMP_LoadModFile().

S_GetSoundWidth()

int S_GetSoundWidth

(

void

)

Definition at line 387 of file snd_main.c.

{
    return snd_renderbuffer ? snd_renderbuffer->format.width : 0;
}

References snd_ringbuffer_t::format, snd_renderbuffer, and snd_format_t::width.

Referenced by XMP_LoadModFile().

S_Init()

void S_Init

(

void

)

Definition at line 706 of file snd_main.c.

{
    Cvar_RegisterVariable(&volume);
    Cvar_RegisterVariable(&bgmvolume);
    Cvar_RegisterVariable(&mastervolume);
    Cvar_RegisterVariable(&snd_staticvolume);
    Cvar_RegisterVariable(&snd_entchannel0volume);
    Cvar_RegisterVariable(&snd_entchannel1volume);
    Cvar_RegisterVariable(&snd_entchannel2volume);
    Cvar_RegisterVariable(&snd_entchannel3volume);
    Cvar_RegisterVariable(&snd_entchannel4volume);
    Cvar_RegisterVariable(&snd_entchannel5volume);
    Cvar_RegisterVariable(&snd_entchannel6volume);
    Cvar_RegisterVariable(&snd_entchannel7volume);
    Cvar_RegisterVariable(&snd_worldchannel0volume);
    Cvar_RegisterVariable(&snd_worldchannel1volume);
    Cvar_RegisterVariable(&snd_worldchannel2volume);
    Cvar_RegisterVariable(&snd_worldchannel3volume);
    Cvar_RegisterVariable(&snd_worldchannel4volume);
    Cvar_RegisterVariable(&snd_worldchannel5volume);
    Cvar_RegisterVariable(&snd_worldchannel6volume);
    Cvar_RegisterVariable(&snd_worldchannel7volume);
    Cvar_RegisterVariable(&snd_playerchannel0volume);
    Cvar_RegisterVariable(&snd_playerchannel1volume);
    Cvar_RegisterVariable(&snd_playerchannel2volume);
    Cvar_RegisterVariable(&snd_playerchannel3volume);
    Cvar_RegisterVariable(&snd_playerchannel4volume);
    Cvar_RegisterVariable(&snd_playerchannel5volume);
    Cvar_RegisterVariable(&snd_playerchannel6volume);
    Cvar_RegisterVariable(&snd_playerchannel7volume);
    Cvar_RegisterVariable(&snd_csqcchannel0volume);
    Cvar_RegisterVariable(&snd_csqcchannel1volume);
    Cvar_RegisterVariable(&snd_csqcchannel2volume);
    Cvar_RegisterVariable(&snd_csqcchannel3volume);
    Cvar_RegisterVariable(&snd_csqcchannel4volume);
    Cvar_RegisterVariable(&snd_csqcchannel5volume);
    Cvar_RegisterVariable(&snd_csqcchannel6volume);
    Cvar_RegisterVariable(&snd_csqcchannel7volume);
    Cvar_RegisterVariable(&snd_channel0volume);
    Cvar_RegisterVariable(&snd_channel1volume);
    Cvar_RegisterVariable(&snd_channel2volume);
    Cvar_RegisterVariable(&snd_channel3volume);
    Cvar_RegisterVariable(&snd_channel4volume);
    Cvar_RegisterVariable(&snd_channel5volume);
    Cvar_RegisterVariable(&snd_channel6volume);
    Cvar_RegisterVariable(&snd_channel7volume);
 
    Cvar_RegisterVariable(&snd_attenuation_exponent);
    Cvar_RegisterVariable(&snd_attenuation_decibel);
 
    Cvar_RegisterVariable(&snd_spatialization_min_radius);
    Cvar_RegisterVariable(&snd_spatialization_max_radius);
    Cvar_RegisterVariable(&snd_spatialization_min);
    Cvar_RegisterVariable(&snd_spatialization_max);
    Cvar_RegisterVariable(&snd_spatialization_power);
    Cvar_RegisterVariable(&snd_spatialization_control);
    Cvar_RegisterVariable(&snd_spatialization_occlusion);
    Cvar_RegisterVariable(&snd_spatialization_prologic);
    Cvar_RegisterVariable(&snd_spatialization_prologic_frontangle);
 
    Cvar_RegisterVariable(&snd_speed);
    Cvar_RegisterVariable(&snd_width);
    Cvar_RegisterVariable(&snd_channels);
    Cvar_RegisterVariable(&snd_bufferlength);
    Cvar_RegisterVariable(&snd_mutewhenidle);
    Cvar_RegisterVariable(&snd_maxchannelvolume);
    Cvar_RegisterVariable(&snd_softclip);
 
    Cvar_RegisterVariable(&snd_startloopingsounds);
    Cvar_RegisterVariable(&snd_startnonloopingsounds);
 
    Cvar_RegisterVariable(&snd_identicalsoundrandomization_time);
    Cvar_RegisterVariable(&snd_identicalsoundrandomization_tics);
 
// COMMANDLINEOPTION: Sound: -nosound disables sound (including CD audio)
    if (Sys_CheckParm("-nosound"))
    {
        // dummy out Play and Play2 because mods stuffcmd that
        Cmd_AddCommand(CF_CLIENT, "play", Cmd_NoOperation_f, "does nothing because -nosound was specified");
        Cmd_AddCommand(CF_CLIENT, "play2", Cmd_NoOperation_f, "does nothing because -nosound was specified");
        return;
    }
 
    snd_mempool = Mem_AllocPool("sound", 0, NULL);
 
// COMMANDLINEOPTION: Sound: -simsound runs sound mixing but with no output
    if (Sys_CheckParm("-simsound"))
        simsound = true;
 
    Cmd_AddCommand(CF_CLIENT, "play", S_Play_f, "play a sound at your current location (not heard by anyone else)");
    Cmd_AddCommand(CF_CLIENT, "play2", S_Play2_f, "play a sound globally throughout the level (not heard by anyone else)");
    Cmd_AddCommand(CF_CLIENT, "playvol", S_PlayVol_f, "play a sound at the specified volume level at your current location (not heard by anyone else)");
    Cmd_AddCommand(CF_CLIENT, "stopsound", S_StopAllSounds_f, "silence");
    Cmd_AddCommand(CF_CLIENT, "pausesound", S_PauseSound_f, "temporary silence");
    Cmd_AddCommand(CF_CLIENT, "soundlist", S_SoundList_f, "list loaded sounds");
    Cmd_AddCommand(CF_CLIENT, "soundinfo", S_SoundInfo_f, "print sound system information (such as channels and speed)");
    Cmd_AddCommand(CF_CLIENT, "snd_restart", S_Restart_f, "restart sound system");
    Cmd_AddCommand(CF_CLIENT, "snd_unloadallsounds", S_UnloadAllSounds_f, "unload all sound files");
 
    Cvar_RegisterVariable(&nosound);
    Cvar_RegisterVariable(&snd_precache);
    Cvar_RegisterVariable(&snd_initialized);
    Cvar_RegisterVariable(&snd_streaming);
    Cvar_RegisterVariable(&snd_streaming_length);
    Cvar_RegisterVariable(&ambient_level);
    Cvar_RegisterVariable(&ambient_fade);
    Cvar_RegisterVariable(&snd_show);
    Cvar_RegisterVariable(&snd_waterfx);
    Cvar_RegisterVariable(&_snd_mixahead);
    Cvar_RegisterVariable(&snd_swapstereo); // for people with backwards sound wiring
    Cvar_RegisterVariable(&snd_channellayout);
    Cvar_RegisterVariable(&snd_soundradius);
 
    Cvar_SetValueQuick(&snd_initialized, true);
 
    known_sfx = NULL;
 
    total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;   // no statics
    memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));
 
    OGG_OpenLibrary ();
#ifdef USEXMP
    XMP_OpenLibrary ();
#endif
 
    CDAudio_Init();
}

References _snd_mixahead, ambient_fade, ambient_level, bgmvolume, CDAudio_Init(), CF_CLIENT, channels, Cmd_AddCommand(), Cmd_NoOperation_f(), Cvar_RegisterVariable(), Cvar_SetValueQuick(), known_sfx, mastervolume, MAX_CHANNELS, MAX_DYNAMIC_CHANNELS, Mem_AllocPool, nosound, NULL, NUM_AMBIENTS, OGG_OpenLibrary(), S_PauseSound_f(), S_Play2_f(), S_Play_f(), S_PlayVol_f(), S_Restart_f(), S_SoundInfo_f(), S_SoundList_f(), S_StopAllSounds_f(), S_UnloadAllSounds_f(), simsound, snd_attenuation_decibel, snd_attenuation_exponent, snd_bufferlength, snd_channel0volume, snd_channel1volume, snd_channel2volume, snd_channel3volume, snd_channel4volume, snd_channel5volume, snd_channel6volume, snd_channel7volume, snd_channellayout, snd_channels, snd_csqcchannel0volume, snd_csqcchannel1volume, snd_csqcchannel2volume, snd_csqcchannel3volume, snd_csqcchannel4volume, snd_csqcchannel5volume, snd_csqcchannel6volume, snd_csqcchannel7volume, snd_entchannel0volume, snd_entchannel1volume, snd_entchannel2volume, snd_entchannel3volume, snd_entchannel4volume, snd_entchannel5volume, snd_entchannel6volume, snd_entchannel7volume, snd_identicalsoundrandomization_tics, snd_identicalsoundrandomization_time, snd_initialized, snd_maxchannelvolume, snd_mempool, snd_mutewhenidle, snd_playerchannel0volume, snd_playerchannel1volume, snd_playerchannel2volume, snd_playerchannel3volume, snd_playerchannel4volume, snd_playerchannel5volume, snd_playerchannel6volume, snd_playerchannel7volume, snd_precache, snd_show, snd_softclip, snd_soundradius, snd_spatialization_control, snd_spatialization_max, snd_spatialization_max_radius, snd_spatialization_min, snd_spatialization_min_radius, snd_spatialization_occlusion, snd_spatialization_power, snd_spatialization_prologic, snd_spatialization_prologic_frontangle, snd_speed, snd_startloopingsounds, snd_startnonloopingsounds, snd_staticvolume, snd_streaming, snd_streaming_length, snd_swapstereo, snd_waterfx, snd_width, snd_worldchannel0volume, snd_worldchannel1volume, snd_worldchannel2volume, snd_worldchannel3volume, snd_worldchannel4volume, snd_worldchannel5volume, snd_worldchannel6volume, snd_worldchannel7volume, Sys_CheckParm(), total_channels, volume, and XMP_OpenLibrary().

Referenced by CL_Init().

S_IsSoundPrecached()

qbool S_IsSoundPrecached

(

const sfx_t *

sfx

)

Definition at line 1105 of file snd_main.c.

{
    return (sfx != NULL && sfx->fetcher != NULL) || (sfx == &changevolume_sfx);
}

References changevolume_sfx, and NULL.

Referenced by CL_BeginDownloads().

S_LocalSound()

qbool S_LocalSound

(

const char *

sound

)

Definition at line 2246 of file snd_main.c.

{
    return S_LocalSoundEx(sound, 0, 1);
}

References S_LocalSoundEx().

Referenced by Con_MaskPrint(), M_Demo_Key(), M_Draw(), M_GameOptions_Key(), M_Keys_Key(), M_LanConfig_Key(), M_Load_Key(), M_Main_Key(), M_Menu_ModList_AdjustSliders(), M_Menu_Options_AdjustSliders(), M_Menu_Options_ColorControl_AdjustSliders(), M_Menu_Options_Effects_AdjustSliders(), M_Menu_Options_Graphics_AdjustSliders(), M_Menu_Video_AdjustSliders(), M_ModList_Key(), M_MultiPlayer_Key(), M_Options_ColorControl_Key(), M_Options_Effects_Key(), M_Options_Graphics_Key(), M_Options_Key(), M_Save_Key(), M_ServerList_Key(), M_Setup_Key(), M_SinglePlayer_Key(), M_Transfusion_Episode_Key(), M_Transfusion_Skill_Key(), M_Video_Key(), and VM_localsound().

S_LocalSoundEx()

qbool S_LocalSoundEx	(	const char *	sound,
		int	chan,
		float	fvol )

Definition at line 2217 of file snd_main.c.

{
    sfx_t   *sfx;
    int     ch_ind;
 
    if (!snd_initialized.integer || nosound.integer)
        return true;
 
    sfx = S_PrecacheSound (sound, true, false);
    if (!sfx)
    {
        Con_Printf("S_LocalSound: can't precache %s\n", sound);
        return false;
    }
 
    // menu sounds must not be freed on level change
    sfx->flags |= SFXFLAG_MENUSOUND;
 
    // fun fact: in Quake 1, this used -1 "replace any entity channel",
    // which we no longer support anyway
    // changed by Black in r4297 "Changed S_LocalSound to play multiple sounds at a time."
    ch_ind = S_StartSound (cl.viewentity, chan, sfx, vec3_origin, fvol, 0);
    if (ch_ind < 0)
        return false;
 
    channels[ch_ind].flags |= CHANNELFLAG_LOCALSOUND;
    return true;
}

References CHANNELFLAG_LOCALSOUND, channels, cl, Con_Printf(), channel_t::flags, cvar_t::integer, nosound, S_PrecacheSound(), S_StartSound(), SFXFLAG_MENUSOUND, snd_initialized, vec3_origin, and client_state_t::viewentity.

Referenced by S_LocalSound(), and VM_localsound().

S_PaintAndSubmit()

static void S_PaintAndSubmit ( void )

static

Definition at line 1895 of file snd_main.c.

{
    unsigned int newsoundtime, paintedtime, endtime, maxtime, usedframes;
    int usesoundtimehack;
    static int soundtimehack = -1;
    static int oldsoundtime = 0;
 
    if (snd_renderbuffer == NULL || nosound.integer)
        return;
 
    // Update sound time
    snd_usethreadedmixing = false;
    usesoundtimehack = true;
    if (cls.timedemo) // SUPER NASTY HACK to mix non-realtime sound for more reliable benchmarking
    {
        usesoundtimehack = 1;
        newsoundtime = (unsigned int)((double)cl.mtime[0] * (double)snd_renderbuffer->format.speed);
    }
#ifdef CONFIG_VIDEO_CAPTURE
    else if (cls.capturevideo.soundrate && !cls.capturevideo.realtime) // SUPER NASTY HACK to record non-realtime sound
    {
        usesoundtimehack = 2;
        newsoundtime = (unsigned int)((double)cls.capturevideo.frame * (double)snd_renderbuffer->format.speed / (double)cls.capturevideo.framerate);
    }
#endif
    else if (simsound)
    {
        usesoundtimehack = 3;
        newsoundtime = (unsigned int)((host.realtime - snd_starttime) * (double)snd_renderbuffer->format.speed);
    }
    else
    {
#ifdef CONFIG_VIDEO_CAPTURE
        snd_usethreadedmixing = snd_threaded && !cls.capturevideo.soundrate;
#else
        snd_usethreadedmixing = snd_threaded;
#endif
        usesoundtimehack = 0;
        newsoundtime = SndSys_GetSoundTime();
    }
    // if the soundtimehack state changes we need to reset the soundtime
    if (soundtimehack != usesoundtimehack)
    {
        snd_renderbuffer->startframe = snd_renderbuffer->endframe = soundtime = newsoundtime;
 
        // Mute the contents of the submission buffer
        if (simsound || SndSys_LockRenderBuffer ())
        {
            int clear;
            size_t memsize;
 
            clear = (snd_renderbuffer->format.width == 1) ? 0x80 : 0;
            memsize = snd_renderbuffer->maxframes * snd_renderbuffer->format.width * snd_renderbuffer->format.channels;
            memset(snd_renderbuffer->ring, clear, memsize);
 
            if (!simsound)
                SndSys_UnlockRenderBuffer ();
        }
    }
    soundtimehack = usesoundtimehack;
 
    // mixing is always required here when capturing, even if output is muted
    // (capture doesn't use threaded/callback mode)
    if (!soundtimehack && snd_blocked && !cls.capturevideo.active)
        return;
 
    if (snd_usethreadedmixing)
        return; // the audio thread will mix its own data
 
    newsoundtime += extrasoundtime;
    if (newsoundtime < soundtime)
    {
#ifdef CONFIG_VIDEO_CAPTURE
        if ((cls.capturevideo.soundrate != 0) != recording_sound)
        {
            unsigned int additionaltime;
 
            // add some time to extrasoundtime make newsoundtime higher
 
            // The extra time must be a multiple of the render buffer size
            // to avoid modifying the current position in the buffer,
            // some modules write directly to a shared (DMA) buffer
            additionaltime = (soundtime - newsoundtime) + snd_renderbuffer->maxframes - 1;
            additionaltime -= additionaltime % snd_renderbuffer->maxframes;
 
            extrasoundtime += additionaltime;
            newsoundtime += additionaltime;
            Con_DPrintf("S_PaintAndSubmit: new extra sound time = %u\n",
                        extrasoundtime);
        }
        else if (!soundtimehack)
#else
        if (!soundtimehack)
#endif
            Con_Printf("S_PaintAndSubmit: WARNING: newsoundtime < soundtime (%u < %u)\n",
                       newsoundtime, soundtime);
    }
    soundtime = newsoundtime;
#ifdef CONFIG_VIDEO_CAPTURE
    recording_sound = (cls.capturevideo.soundrate != 0);
#endif
 
    // Lock submitbuffer
    if (!simsound && !SndSys_LockRenderBuffer())
    {
        // If the lock failed, stop here
        Con_DPrint(">> S_PaintAndSubmit: SndSys_LockRenderBuffer() failed\n");
        return;
    }
 
    // Check to make sure that we haven't overshot
    paintedtime = snd_renderbuffer->endframe;
    if (paintedtime < soundtime)
        paintedtime = soundtime;
 
    // mix ahead of current position
    if (soundtimehack)
        endtime = soundtime + (unsigned int)(_snd_mixahead.value * (float)snd_renderbuffer->format.speed);
    else
        endtime = soundtime + (unsigned int)(max(_snd_mixahead.value * (float)snd_renderbuffer->format.speed, min(3 * (soundtime - oldsoundtime), 0.3 * (float)snd_renderbuffer->format.speed)));
    usedframes = snd_renderbuffer->endframe - snd_renderbuffer->startframe;
    maxtime = paintedtime + snd_renderbuffer->maxframes - usedframes;
    endtime = min(endtime, maxtime);
 
    while (paintedtime < endtime)
    {
        unsigned int startoffset;
        unsigned int nbframes;
 
        // see how much we can fit in the paint buffer
        nbframes = endtime - paintedtime;
        // limit to the end of the ring buffer (in case of wrapping)
        startoffset = paintedtime % snd_renderbuffer->maxframes;
        nbframes = min(nbframes, snd_renderbuffer->maxframes - startoffset);
 
        // mix into the buffer
        S_MixToBuffer(&snd_renderbuffer->ring[startoffset * snd_renderbuffer->format.width * snd_renderbuffer->format.channels], nbframes);
 
        paintedtime += nbframes;
        snd_renderbuffer->endframe = paintedtime;
    }
    if (!simsound)
        SndSys_UnlockRenderBuffer();
 
    // Remove outdated samples from the ring buffer, if any
    if (snd_renderbuffer->startframe < soundtime)
        snd_renderbuffer->startframe = soundtime;
 
    if (simsound)
        snd_renderbuffer->startframe = snd_renderbuffer->endframe;
    else
        SndSys_Submit();
 
    oldsoundtime = soundtime;
 
    cls.soundstats.latency_milliseconds = (snd_renderbuffer->endframe - snd_renderbuffer->startframe) * 1000 / snd_renderbuffer->format.speed;
    R_TimeReport("audiomix");
}

References _snd_mixahead, snd_format_t::channels, cl, cls, Con_DPrint(), Con_DPrintf(), Con_Printf(), snd_ringbuffer_t::endframe, extrasoundtime, snd_ringbuffer_t::format, host, int(), cvar_t::integer, cl_soundstats_t::latency_milliseconds, max, snd_ringbuffer_t::maxframes, min, client_state_t::mtime, nosound, NULL, R_TimeReport(), host_static_t::realtime, snd_ringbuffer_t::ring, S_MixToBuffer(), simsound, snd_blocked, snd_renderbuffer, snd_starttime, snd_threaded, snd_usethreadedmixing, SndSys_GetSoundTime(), SndSys_LockRenderBuffer(), SndSys_Submit(), SndSys_UnlockRenderBuffer(), client_static_t::soundstats, soundtime, snd_format_t::speed, snd_ringbuffer_t::startframe, client_static_t::timedemo, cvar_t::value, and snd_format_t::width.

Referenced by S_Update().

S_PauseGameSounds()

void S_PauseGameSounds

(

qbool

toggle

)

Definition at line 1749 of file snd_main.c.

{
    unsigned int i;
 
    for (i = 0; i < total_channels; i++)
    {
        channel_t *ch;
 
        ch = &channels[i];
        if (ch->sfx != NULL && ! (ch->flags & CHANNELFLAG_LOCALSOUND))
            S_SetChannelFlag (i, CHANNELFLAG_PAUSED, toggle);
    }
}

References CHANNELFLAG_LOCALSOUND, CHANNELFLAG_PAUSED, channels, channel_t::flags, i, NULL, S_SetChannelFlag(), channel_t::sfx, and total_channels.

Referenced by CL_ParseServerMessage(), and S_PauseSound_f().

S_PauseSound_f()

static void S_PauseSound_f ( cmd_state_t * cmd )

static

Definition at line 368 of file snd_main.c.

{
    if( Cmd_Argc(cmd) != 2 ) {
        Con_Print("pausesound <pause>\n");
        return;
    }
    S_PauseGameSounds(atoi( Cmd_Argv(cmd, 1 ) ) != 0);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), and S_PauseGameSounds().

Referenced by S_Init().

S_Play2_f()

static void S_Play2_f ( cmd_state_t * cmd )

static

Definition at line 311 of file snd_main.c.

{
    S_Play_Common(cmd, 1.0f, 0.0f);
}

References cmd(), and S_Play_Common().

Referenced by S_Init().

S_Play_Common()

static void S_Play_Common ( cmd_state_t * cmd, float fvol, float attenuation )

static

Definition at line 270 of file snd_main.c.

{
    int i, ch_ind;
    char name [MAX_QPATH];
    sfx_t *sfx;
 
    i = 1;
    while (i < Cmd_Argc (cmd))
    {
        // Get the name, and appends ".wav" as an extension if there's none
        dp_strlcpy (name, Cmd_Argv(cmd, i), sizeof (name));
        if (!strrchr (name, '.'))
            dp_strlcat (name, ".wav", sizeof (name));
        i++;
 
        // If we need to get the volume from the command line
        if (fvol == -1.0f)
        {
            fvol = atof (Cmd_Argv(cmd, i));
            i++;
        }
 
        sfx = S_PrecacheSound (name, true, true);
        if (sfx)
        {
            ch_ind = S_StartSound (-1, 0, sfx, listener_origin, fvol, attenuation);
 
            // Free the sfx if the file didn't exist
            if (!sfx->fetcher)
                S_FreeSfx (sfx, false);
            else
                channels[ch_ind].flags |= CHANNELFLAG_LOCALSOUND;
        }
    }
}

References CHANNELFLAG_LOCALSOUND, channels, cmd(), Cmd_Argc(), Cmd_Argv(), dp_strlcat, dp_strlcpy, channel_t::flags, i, listener_origin, MAX_QPATH, name, S_FreeSfx(), S_PrecacheSound(), and S_StartSound().

Referenced by S_Play2_f(), S_Play_f(), and S_PlayVol_f().

S_Play_f()

static void S_Play_f ( cmd_state_t * cmd )

static

Definition at line 306 of file snd_main.c.

{
    S_Play_Common(cmd, 1.0f, 1.0f);
}

References cmd(), and S_Play_Common().

Referenced by S_Init().

S_PlaySfxOnChannel()

static void S_PlaySfxOnChannel ( sfx_t * sfx, channel_t * target_chan, unsigned int flags, vec3_t origin, float fvol, float attenuation, qbool isstatic, int entnum, int entchannel, int startpos, float fspeed )

static

Definition at line 1514 of file snd_main.c.

{
    if (!sfx)
    {
        Con_Printf("S_PlaySfxOnChannel called with NULL??\n");
        return;
    }
 
    if ((sfx->loopstart < sfx->total_length) || (flags & CHANNELFLAG_FORCELOOP))
    {
        if(!snd_startloopingsounds.integer)
            return;
    }
    else
    {
        if(!snd_startnonloopingsounds.integer)
            return;
    }
 
    // Initialize the channel
    // a crash was reported on an in-use channel, so check here...
    if (target_chan->sfx)
    {
        int channelindex = (int)(target_chan - channels);
        Con_Printf("S_PlaySfxOnChannel(%s): channel %i already in use??  Clearing.\n", sfx->name, channelindex);
        S_StopChannel (channelindex, true, false);
    }
    // We MUST set sfx LAST because otherwise we could crash a threaded mixer
    // (otherwise we'd have to call SndSys_LockRenderBuffer here)
    memset (target_chan, 0, sizeof (*target_chan));
    VectorCopy (origin, target_chan->origin);
    target_chan->flags = flags;
    target_chan->position = startpos; // start of the sound
    target_chan->entnum = entnum;
    target_chan->entchannel = entchannel;
 
    // If it's a static sound
    if (isstatic)
    {
        if (sfx->loopstart >= sfx->total_length && (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEWORLD))
            Con_DPrintf("Quake compatibility warning: Static sound \"%s\" is not looped\n", sfx->name);
        target_chan->distfade = attenuation / (64.0f * snd_soundradius.value);
    }
    else
        target_chan->distfade = attenuation / snd_soundradius.value;
 
    // set the listener volumes
    S_SetChannelVolume(target_chan - channels, fvol);
    S_SetChannelSpeed(target_chan - channels, fspeed);
    SND_Spatialize_WithSfx (target_chan, isstatic, sfx);
 
    // finally, set the sfx pointer, so the channel becomes valid for playback
    // and will be noticed by the mixer
    target_chan->sfx = sfx;
}

References CHANNELFLAG_FORCELOOP, channels, cls, Con_DPrintf(), Con_Printf(), channel_t::distfade, channel_t::entchannel, channel_t::entnum, entnum, channel_t::flags, flags, int(), cvar_t::integer, channel_t::origin, origin, channel_t::position, client_static_t::protocol, PROTOCOL_QUAKE, PROTOCOL_QUAKEWORLD, S_SetChannelSpeed(), S_SetChannelVolume(), S_StopChannel(), channel_t::sfx, snd_soundradius, SND_Spatialize_WithSfx(), snd_startloopingsounds, snd_startnonloopingsounds, cvar_t::value, and VectorCopy.

Referenced by S_StartSound_StartPosition_Flags(), and S_StaticSound().

S_PlayVol_f()

static void S_PlayVol_f ( cmd_state_t * cmd )

static

Definition at line 316 of file snd_main.c.

{
    S_Play_Common(cmd, -1.0f, 0.0f);
}

References cmd(), and S_Play_Common().

Referenced by S_Init().

S_PrecacheSound()

sfx_t * S_PrecacheSound	(	const char *	name,
		qbool	complain,
		qbool	levelsound )

Definition at line 1048 of file snd_main.c.

{
    sfx_t *sfx;
 
    if (!snd_initialized.integer)
        return NULL;
 
    if (name == NULL || name[0] == 0)
        return NULL;
 
    sfx = S_FindName (name);
 
    if (sfx == NULL)
        return NULL;
 
    // clear the FILEMISSING flag so that S_LoadSound will try again on a
    // previously missing file
    sfx->flags &= ~ SFXFLAG_FILEMISSING;
 
    // set a flag to indicate this has been precached for this level or permanently
    if (levelsound)
        sfx->flags |= SFXFLAG_LEVELSOUND;
    else
        sfx->flags |= SFXFLAG_MENUSOUND;
 
    if (!nosound.integer && snd_precache.integer)
        S_LoadSound(sfx, complain);
 
    return sfx;
}

References cvar_t::integer, name, nosound, NULL, S_FindName(), S_LoadSound(), SFXFLAG_LEVELSOUND, SFXFLAG_MENUSOUND, snd_initialized, and snd_precache.

Referenced by CDAudio_Play_byName(), CL_BeginDownloads(), CL_ParseServerInfo(), CL_ParseServerMessage(), dpvsimpledecode_open(), jam_open(), LibAvW_OpenVideo(), QW_CL_RequestNextDownload(), S_ClearUsed(), S_LocalSoundEx(), S_Play_Common(), and VM_precache_sound().

S_PurgeUnused()

void S_PurgeUnused

(

void

)

Definition at line 1028 of file snd_main.c.

{
    sfx_t *sfx;
    sfx_t *sfxnext;
 
    // Free all not-precached per-level sfx
    for (sfx = known_sfx;sfx;sfx = sfxnext)
    {
        sfxnext = sfx->next;
        if (!(sfx->flags & (SFXFLAG_LEVELSOUND | SFXFLAG_MENUSOUND)))
            S_FreeSfx (sfx, false);
    }
}

References known_sfx, S_FreeSfx(), SFXFLAG_LEVELSOUND, and SFXFLAG_MENUSOUND.

Referenced by CL_SignonReply().

S_Restart_f()

static void S_Restart_f ( cmd_state_t * cmd )

static

Definition at line 687 of file snd_main.c.

{
    // NOTE: we can't free all sounds if we are running a map (this frees sfx_t that are still referenced by precaches)
    // So, refuse to do this if we are connected.
    if(cls.state == ca_connected)
    {
        Con_Printf("snd_restart would wreak havoc if you do that while connected!\n");
        return;
    }
 
    S_Shutdown();
    S_Startup();
}

References ca_connected, cls, Con_Printf(), S_Shutdown(), S_Startup(), and client_static_t::state.

Referenced by S_Init().

S_SetChannelFlag()

qbool S_SetChannelFlag	(	unsigned int	ch_ind,
		unsigned int	flag,
		qbool	value )

Definition at line 1679 of file snd_main.c.

{
    if (ch_ind >= total_channels)
        return false;
 
    if (flag != CHANNELFLAG_FORCELOOP &&
        flag != CHANNELFLAG_PAUSED &&
        flag != CHANNELFLAG_FULLVOLUME &&
        flag != CHANNELFLAG_LOCALSOUND)
        return false;
 
    if (value)
        channels[ch_ind].flags |= flag;
    else
        channels[ch_ind].flags &= ~flag;
 
    return true;
}

References CHANNELFLAG_FORCELOOP, CHANNELFLAG_FULLVOLUME, CHANNELFLAG_LOCALSOUND, CHANNELFLAG_PAUSED, channels, channel_t::flags, total_channels, and value.

Referenced by CDAudio_Pause(), CDAudio_Resume(), S_PauseGameSounds(), and S_StartSound_StartPosition_Flags().

S_SetChannelLayout()

static void S_SetChannelLayout ( void )

static

Definition at line 395 of file snd_main.c.

{
    unsigned int i;
    listener_t swaplistener;
    listener_t *listeners;
    int layout;
 
    for (i = 0; i < SND_SPEAKERLAYOUTS; i++)
        if (snd_speakerlayouts[i].channels == snd_renderbuffer->format.channels)
            break;
    if (i >= SND_SPEAKERLAYOUTS)
    {
        Con_Printf("S_SetChannelLayout: can't find the speaker layout for %hu channels. Defaulting to mono output\n",
                   snd_renderbuffer->format.channels);
        i = SND_SPEAKERLAYOUTS - 1;
    }
 
    snd_speakerlayout = snd_speakerlayouts[i];
    listeners = snd_speakerlayout.listeners;
 
    // Swap the left and right channels if snd_swapstereo is set
    if (boolxor(snd_swapstereo.integer, v_flipped.integer))
    {
        switch (snd_speakerlayout.channels)
        {
            case 8:
                SWAP_LISTENERS(listeners[6], listeners[7], swaplistener);
                // no break
            case 4:
            case 6:
                SWAP_LISTENERS(listeners[2], listeners[3], swaplistener);
                // no break
            case 2:
                SWAP_LISTENERS(listeners[0], listeners[1], swaplistener);
                break;
 
            default:
            case 1:
                // Nothing to do
                break;
        }
    }
 
    // Sanity check
    if (snd_channellayout.integer < SND_CHANNELLAYOUT_AUTO ||
        snd_channellayout.integer > SND_CHANNELLAYOUT_ALSA)
        Cvar_SetValueQuick (&snd_channellayout, SND_CHANNELLAYOUT_STANDARD);
 
    if (snd_channellayout.integer == SND_CHANNELLAYOUT_AUTO)
    {
        // If we're in the sound engine initialization
        if (current_channellayout_used == SND_CHANNELLAYOUT_AUTO)
        {
            layout = SND_CHANNELLAYOUT_STANDARD;
            Cvar_SetValueQuick (&snd_channellayout, layout);
        }
        else
            layout = current_channellayout_used;
    }
    else
        layout = snd_channellayout.integer;
 
    // Convert our layout (= ALSA) to the standard layout if necessary
    if (snd_speakerlayout.channels == 6 || snd_speakerlayout.channels == 8)
    {
        if (layout == SND_CHANNELLAYOUT_STANDARD)
        {
            SWAP_LISTENERS(listeners[2], listeners[4], swaplistener);
            SWAP_LISTENERS(listeners[3], listeners[5], swaplistener);
        }
 
        Con_Printf("S_SetChannelLayout: using %s speaker layout for 3D sound\n",
                   (layout == SND_CHANNELLAYOUT_ALSA) ? "ALSA" : "standard");
    }
 
    current_swapstereo = boolxor(snd_swapstereo.integer, v_flipped.integer);
    current_channellayout = snd_channellayout.integer;
    current_channellayout_used = layout;
}

References boolxor, channels, snd_format_t::channels, speakerlayout_t::channels, Con_Printf(), current_channellayout, current_channellayout_used, current_swapstereo, Cvar_SetValueQuick(), snd_ringbuffer_t::format, i, cvar_t::integer, speakerlayout_t::listeners, snd_channellayout, SND_CHANNELLAYOUT_ALSA, SND_CHANNELLAYOUT_AUTO, SND_CHANNELLAYOUT_STANDARD, snd_renderbuffer, snd_speakerlayout, SND_SPEAKERLAYOUTS, snd_speakerlayouts, snd_swapstereo, SWAP_LISTENERS, and v_flipped.

Referenced by S_Startup(), and S_Update().

S_SetChannelSpeed()

void S_SetChannelSpeed	(	unsigned int	ch_ind,
		float	fspeed )

Definition at line 1768 of file snd_main.c.

{
    channels[ch_ind].basespeed = fspeed;
}

References channel_t::basespeed, and channels.

Referenced by S_PlaySfxOnChannel(), and S_StartSound_StartPosition_Flags().

S_SetChannelVolume()

void S_SetChannelVolume	(	unsigned int	ch_ind,
		float	fvol )

Definition at line 1763 of file snd_main.c.

{
    channels[ch_ind].basevolume = fvol;
}

References channel_t::basevolume, and channels.

Referenced by CDAudio_SetVolume(), S_PlaySfxOnChannel(), and S_StartSound_StartPosition_Flags().

S_Shutdown()

void S_Shutdown

(

void

)

Definition at line 668 of file snd_main.c.

{
    if (snd_renderbuffer == NULL)
        return;
 
    CDAudio_Shutdown();
 
    oldpaintedtime = snd_renderbuffer->endframe;
 
    if (simsound)
    {
        Mem_Free(snd_renderbuffer->ring);
        Mem_Free(snd_renderbuffer);
        snd_renderbuffer = NULL;
    }
    else
        SndSys_Shutdown();
}

References CDAudio_Shutdown(), snd_ringbuffer_t::endframe, Mem_Free, NULL, oldpaintedtime, snd_ringbuffer_t::ring, simsound, snd_renderbuffer, and SndSys_Shutdown().

Referenced by S_Restart_f(), and S_Terminate().

S_SoundInfo_f()

static void S_SoundInfo_f ( cmd_state_t * cmd )

static

Definition at line 353 of file snd_main.c.

{
    if (snd_renderbuffer == NULL)
    {
        Con_Print("sound system not started\n");
        return;
    }
 
    Con_Printf("%5d speakers\n", snd_renderbuffer->format.channels);
    Con_Printf("%5d frames\n", snd_renderbuffer->maxframes);
    Con_Printf("%5d samplebits\n", snd_renderbuffer->format.width * 8);
    Con_Printf("%5d speed\n", snd_renderbuffer->format.speed);
    Con_Printf("%5u total_channels\n", total_channels);
}

References snd_format_t::channels, Con_Print(), Con_Printf(), snd_ringbuffer_t::format, snd_ringbuffer_t::maxframes, NULL, snd_renderbuffer, snd_format_t::speed, total_channels, and snd_format_t::width.

Referenced by S_Init().

S_SoundLength()

float S_SoundLength

(

const char *

name

)

Definition at line 1085 of file snd_main.c.

{
    sfx_t *sfx;
 
    if (!snd_initialized.integer)
        return -1;
    if (name == NULL || name[0] == 0)
        return -1;
 
    sfx = S_FindName(name);
    if (sfx == NULL)
        return -1;
    return sfx->total_length / (float) S_GetSoundRate();
}

References float, cvar_t::integer, name, NULL, S_FindName(), S_GetSoundRate(), and snd_initialized.

Referenced by VM_soundlength().

S_SoundList_f()

static void S_SoundList_f ( cmd_state_t * cmd )

static

Definition at line 321 of file snd_main.c.

{
    unsigned int i;
    sfx_t *sfx;
    unsigned int total;
 
    total = 0;
    for (sfx = known_sfx, i = 0; sfx != NULL; sfx = sfx->next, i++)
    {
        if (sfx->fetcher != NULL)
        {
            unsigned int size;
 
            size = (unsigned int)sfx->memsize;
            Con_Printf ("%c%c%c(%5iHz %2db %6s) %8i : %s\n",
                        (sfx->loopstart < sfx->total_length) ? 'L' : ' ',
                        (sfx->flags & SFXFLAG_STREAMED) ? 'S' : ' ',
                        (sfx->flags & SFXFLAG_MENUSOUND) ? 'P' : ' ',
                        sfx->format.speed,
                        sfx->format.width * 8,
                        (sfx->format.channels == 1) ? "mono" : "stereo",
                        size,
                        sfx->name);
            total += size;
        }
        else
            Con_Printf ("    (  unknown  ) unloaded : %s\n", sfx->name);
    }
    Con_Printf("Total resident: %i\n", total);
}

References Con_Printf(), i, int(), known_sfx, NULL, SFXFLAG_MENUSOUND, SFXFLAG_STREAMED, and size.

Referenced by S_Init().

S_StartSound()

int S_StartSound	(	int	entnum,
		int	entchannel,
		sfx_t *	sfx,
		vec3_t	origin,
		float	fvol,
		float	attenuation )

S_StartSound returns the channel index, or -1 if an error occurred.

Definition at line 1643 of file snd_main.c.

{
    return S_StartSound_StartPosition_Flags(entnum, entchannel, sfx, origin, fvol, attenuation, 0, CHANNELFLAG_NONE, 1.0f);
}

References CHANNELFLAG_NONE, entnum, origin, and S_StartSound_StartPosition_Flags().

Referenced by CL_ParseTempEntity(), dpvsimpledecode_open(), jam_open(), libavw_decodeframe(), S_LocalSoundEx(), S_Play_Common(), VM_CL_pointsound(), VM_CL_te_explosion(), VM_CL_te_explosion2(), VM_CL_te_explosionquad(), VM_CL_te_gunshot(), VM_CL_te_gunshotquad(), VM_CL_te_knightspike(), VM_CL_te_spike(), VM_CL_te_spikequad(), VM_CL_te_superspike(), VM_CL_te_superspikequad(), VM_CL_te_tarexplosion(), and VM_CL_te_wizspike().

S_StartSound_StartPosition_Flags()

int S_StartSound_StartPosition_Flags	(	int	entnum,
		int	entchannel,
		sfx_t *	sfx,
		vec3_t	origin,
		float	fvol,
		float	attenuation,
		float	startposition,
		int	flags,
		float	fspeed )

Definition at line 1571 of file snd_main.c.

{
    channel_t *target_chan, *check, *ch;
    int     ch_idx, startpos, i;
 
    if (snd_renderbuffer == NULL || sfx == NULL || nosound.integer)
        return -1;
 
    if(sfx == &changevolume_sfx)
    {
        if (!IS_CHAN_SINGLE(entchannel))
            return -1;
        for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++)
        {
            ch = &channels[ch_idx];
            if (ch->entnum == entnum && ch->entchannel == entchannel)
            {
                S_SetChannelVolume(ch_idx, fvol);
                S_SetChannelSpeed(ch_idx, fspeed);
                for(i = 1; i > 0 && (i <= flags || i <= (int) channels[ch_idx].flags); i <<= 1)
                    if((flags ^ channels[ch_idx].flags) & i)
                        S_SetChannelFlag(ch_idx, i, (flags & i) != 0);
                ch->distfade = attenuation / snd_soundradius.value;
                SND_Spatialize(ch, false);
                return ch_idx;
            }
        }
        return -1;
    }
 
    if (sfx->fetcher == NULL)
        return -1;
 
    // Pick a channel to play on
    target_chan = SND_PickChannel(entnum, entchannel);
    if (!target_chan)
        return -1;
 
    // if an identical sound has also been started this frame, offset the pos
    // a bit to keep it from just making the first one louder
    check = &channels[NUM_AMBIENTS];
    startpos = (int)(startposition * sfx->format.speed);
    if (startpos == 0)
    {
        for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++, check++)
        {
            if (check == target_chan)
                continue;
            if (check->sfx == sfx && check->position == 0 && check->basespeed == fspeed)
            {
                // calculate max offset
                float maxtime = snd_identicalsoundrandomization_time.value;
                float maxtics = snd_identicalsoundrandomization_tics.value;
                float maxticsdelta = ((cls.state == ca_connected) ? (maxtics * (cl.mtime[0] - cl.mtime[1])) : 0);
                float maxdelta = 0;
                if(maxticsdelta == 0 || fabs(maxticsdelta) > fabs(maxtime))
                    maxdelta = maxtime;
                else
                    maxdelta = fabs(maxticsdelta) * ((maxtime > 0) ? 1 : -1);
 
                // use negative pos offset to delay this sound effect
                startpos = lhrandom(0, maxdelta * sfx->format.speed);
                break;
            }
        }
    }
 
    S_PlaySfxOnChannel (sfx, target_chan, flags, origin, fvol, attenuation, false, entnum, entchannel, startpos, fspeed);
 
    return (target_chan - channels);
}

References channel_t::basespeed, ca_connected, changevolume_sfx, channels, cl, cls, channel_t::distfade, channel_t::entchannel, channel_t::entnum, entnum, fabs(), channel_t::flags, flags, i, int(), cvar_t::integer, IS_CHAN_SINGLE, lhrandom, MAX_DYNAMIC_CHANNELS, client_state_t::mtime, nosound, NULL, NUM_AMBIENTS, origin, channel_t::position, S_PlaySfxOnChannel(), S_SetChannelFlag(), S_SetChannelSpeed(), S_SetChannelVolume(), channel_t::sfx, snd_identicalsoundrandomization_tics, snd_identicalsoundrandomization_time, SND_PickChannel(), snd_renderbuffer, snd_soundradius, SND_Spatialize(), client_static_t::state, and cvar_t::value.

Referenced by CDAudio_Play_byName(), CL_ParseStartSoundPacket(), S_StartSound(), and VM_CL_sound().

S_Startup()

void S_Startup

(

void

)

Definition at line 476 of file snd_main.c.

{
    snd_format_t chosen_fmt;
    static snd_format_t prev_render_format = {0, 0, 0};
    char* env;
#if _MSC_VER >= 1400
    size_t envlen;
#endif
    int i;
 
    if (!snd_initialized.integer)
        return;
 
    // Get the starting sound format from the cvars
    chosen_fmt.speed = snd_speed.integer;
    chosen_fmt.width = snd_width.integer;
    chosen_fmt.channels = snd_channels.integer;
 
    // Check the environment variables to see if the player wants a particular sound format
#if _MSC_VER >= 1400
    _dupenv_s(&env, &envlen, "QUAKE_SOUND_CHANNELS");
#else
    env = getenv("QUAKE_SOUND_CHANNELS");
#endif
    if (env != NULL)
    {
        chosen_fmt.channels = atoi (env);
#if _MSC_VER >= 1400
        free(env);
#endif
    }
#if _MSC_VER >= 1400
    _dupenv_s(&env, &envlen, "QUAKE_SOUND_SPEED");
#else
    env = getenv("QUAKE_SOUND_SPEED");
#endif
    if (env != NULL)
    {
        chosen_fmt.speed = atoi (env);
#if _MSC_VER >= 1400
        free(env);
#endif
    }
#if _MSC_VER >= 1400
    _dupenv_s(&env, &envlen, "QUAKE_SOUND_SAMPLEBITS");
#else
    env = getenv("QUAKE_SOUND_SAMPLEBITS");
#endif
    if (env != NULL)
    {
        chosen_fmt.width = atoi (env) / 8;
#if _MSC_VER >= 1400
        free(env);
#endif
    }
 
    // Parse the command line to see if the player wants a particular sound format
// COMMANDLINEOPTION: Sound: -sndquad sets sound output to 4 channel surround
    if (Sys_CheckParm ("-sndquad") != 0)
    {
        chosen_fmt.channels = 4;
    }
// COMMANDLINEOPTION: Sound: -sndstereo sets sound output to stereo
    else if (Sys_CheckParm ("-sndstereo") != 0)
    {
        chosen_fmt.channels = 2;
    }
// COMMANDLINEOPTION: Sound: -sndmono sets sound output to mono
    else if (Sys_CheckParm ("-sndmono") != 0)
    {
        chosen_fmt.channels = 1;
    }
// COMMANDLINEOPTION: Sound: -sndspeed <hz> chooses sound output rate (supported values are 48000, 44100, 32000, 24000, 22050, 16000, 11025 (quake), 8000)
    i = Sys_CheckParm ("-sndspeed");
    if (0 < i && i < sys.argc - 1)
    {
        chosen_fmt.speed = atoi (sys.argv[i + 1]);
    }
// COMMANDLINEOPTION: Sound: -sndbits <bits> chooses 8 bit or 16 bit or 32bit float sound output
    i = Sys_CheckParm ("-sndbits");
    if (0 < i && i < sys.argc - 1)
    {
        chosen_fmt.width = atoi (sys.argv[i + 1]) / 8;
    }
 
#if 0
    // LadyHavoc: now you can with the resampler...
    // You can't change sound speed after start time (not yet supported)
    if (prev_render_format.speed != 0)
    {
        if (chosen_fmt.speed != prev_render_format.speed)
        {
            Con_Printf("S_Startup: sound speed has changed! This is NOT supported yet. Falling back to previous speed (%u Hz)\n",
                       prev_render_format.speed);
            chosen_fmt.speed = prev_render_format.speed;
        }
    }
#endif
 
    // Sanity checks
    if (chosen_fmt.speed < SND_MIN_SPEED)
    {
        chosen_fmt.speed = SND_MIN_SPEED;
    }
    else if (chosen_fmt.speed > SND_MAX_SPEED)
    {
        chosen_fmt.speed = SND_MAX_SPEED;
    }
 
    if (chosen_fmt.width < SND_MIN_WIDTH)
    {
        chosen_fmt.width = SND_MIN_WIDTH;
    }
    else if (chosen_fmt.width == 3)
    {
        chosen_fmt.width = 4;
    }
    else if (chosen_fmt.width > SND_MAX_WIDTH)
    {
        chosen_fmt.width = SND_MAX_WIDTH;
    }
 
    if (chosen_fmt.channels < SND_MIN_CHANNELS)
    {
        chosen_fmt.channels = SND_MIN_CHANNELS;
    }
    else if (chosen_fmt.channels > SND_MAX_CHANNELS)
    {
        chosen_fmt.channels = SND_MAX_CHANNELS;
    }
 
    // create the sound buffer used for sumitting the samples to the plaform-dependent module
    if (!simsound)
    {
        Con_Printf("S_Startup: initializing sound output format: %dHz, %d bit, %d channels...\n",
                    chosen_fmt.speed,
                    chosen_fmt.width,
                    chosen_fmt.channels);
 
        if (!SndSys_Init(&chosen_fmt))
        {
            Con_Print("S_Startup: SndSys_Init failed.\n");
            return;
        }
    }
    else
    {
        snd_renderbuffer = Snd_CreateRingBuffer(&chosen_fmt, 0, NULL);
        Con_Print ("S_Startup: simulating sound output\n");
    }
 
    memcpy(&prev_render_format, &snd_renderbuffer->format, sizeof(prev_render_format));
    Con_Printf("Sound format: %dHz, %d channels, %d bits per sample\n",
               chosen_fmt.speed, chosen_fmt.channels, chosen_fmt.width * 8);
 
    // Update the cvars
    if (snd_speed.integer != (int)chosen_fmt.speed)
        Cvar_SetValueQuick(&snd_speed, chosen_fmt.speed);
    if (snd_width.integer != chosen_fmt.width)
        Cvar_SetValueQuick(&snd_width, chosen_fmt.width);
    if (snd_channels.integer != chosen_fmt.channels)
        Cvar_SetValueQuick(&snd_channels, chosen_fmt.channels);
 
    current_channellayout_used = SND_CHANNELLAYOUT_AUTO;
    S_SetChannelLayout();
 
    snd_starttime = host.realtime;
 
    // If the sound module has already run, add an extra time to make sure
    // the sound time doesn't decrease, to not confuse playing SFXs
    if (oldpaintedtime != 0)
    {
        // The extra time must be a multiple of the render buffer size
        // to avoid modifying the current position in the buffer,
        // some modules write directly to a shared (DMA) buffer
        extrasoundtime = oldpaintedtime + snd_renderbuffer->maxframes - 1;
        extrasoundtime -= extrasoundtime % snd_renderbuffer->maxframes;
        Con_Printf("S_Startup: extra sound time = %u\n", extrasoundtime);
 
        soundtime = extrasoundtime;
    }
    else
        extrasoundtime = 0;
    snd_renderbuffer->startframe = soundtime;
    snd_renderbuffer->endframe = soundtime;
#ifdef CONFIG_VIDEO_CAPTURE
    recording_sound = false;
#endif
 
    CDAudio_Startup();
}

References sys_t::argc, sys_t::argv, CDAudio_Startup(), snd_format_t::channels, Con_Print(), Con_Printf(), current_channellayout_used, Cvar_SetValueQuick(), snd_ringbuffer_t::endframe, extrasoundtime, snd_ringbuffer_t::format, host, i, cvar_t::integer, snd_ringbuffer_t::maxframes, NULL, oldpaintedtime, host_static_t::realtime, S_SetChannelLayout(), simsound, SND_CHANNELLAYOUT_AUTO, snd_channels, Snd_CreateRingBuffer(), snd_initialized, SND_MAX_CHANNELS, SND_MAX_SPEED, SND_MAX_WIDTH, SND_MIN_CHANNELS, SND_MIN_SPEED, SND_MIN_WIDTH, snd_renderbuffer, snd_speed, snd_starttime, snd_width, SndSys_Init(), soundtime, snd_format_t::speed, snd_ringbuffer_t::startframe, sys, Sys_CheckParm(), and snd_format_t::width.

Referenced by Host_Init(), and S_Restart_f().

S_StaticSound()

void S_StaticSound	(	sfx_t *	sfx,
		vec3_t	origin,
		float	fvol,
		float	attenuation )

Definition at line 1809 of file snd_main.c.

{
    channel_t   *target_chan;
 
    if (snd_renderbuffer == NULL || sfx == NULL || nosound.integer)
        return;
    if (!sfx->fetcher)
    {
        Con_Printf ("S_StaticSound: \"%s\" hasn't been precached\n", sfx->name);
        return;
    }
 
    if (total_channels == MAX_CHANNELS)
    {
        Con_Print("S_StaticSound: total_channels == MAX_CHANNELS\n");
        return;
    }
 
    target_chan = &channels[total_channels++];
    S_PlaySfxOnChannel (sfx, target_chan, CHANNELFLAG_FORCELOOP, origin, fvol, attenuation, true, 0, 0, 0, 1.0f);
}

References CHANNELFLAG_FORCELOOP, channels, Con_Print(), Con_Printf(), cvar_t::integer, MAX_CHANNELS, nosound, NULL, origin, S_PlaySfxOnChannel(), snd_renderbuffer, and total_channels.

Referenced by CL_ParseStaticSound(), and VM_CL_ambientsound().

S_StopAllSounds()

void S_StopAllSounds

(

void

)

Definition at line 1710 of file snd_main.c.

{
    unsigned int i;
 
    // TOCHECK: is this test necessary?
    if (snd_renderbuffer == NULL)
        return;
 
    // stop CD audio because it may be using a faketrack
    CDAudio_Stop();
 
    if (simsound || SndSys_LockRenderBuffer ())
    {
        int clear;
        size_t memsize;
 
        for (i = 0; i < total_channels; i++)
            if (channels[i].sfx)
                S_StopChannel (i, false, false);
 
        total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;   // no statics
        memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));
 
        // Mute the contents of the submittion buffer
        clear = (snd_renderbuffer->format.width == 1) ? 0x80 : 0;
        memsize = snd_renderbuffer->maxframes * snd_renderbuffer->format.width * snd_renderbuffer->format.channels;
        memset(snd_renderbuffer->ring, clear, memsize);
 
        if (!simsound)
            SndSys_UnlockRenderBuffer ();
    }
}

References CDAudio_Stop(), channels, snd_format_t::channels, snd_ringbuffer_t::format, i, MAX_CHANNELS, MAX_DYNAMIC_CHANNELS, snd_ringbuffer_t::maxframes, NULL, NUM_AMBIENTS, snd_ringbuffer_t::ring, S_StopChannel(), simsound, snd_renderbuffer, SndSys_LockRenderBuffer(), SndSys_UnlockRenderBuffer(), total_channels, and snd_format_t::width.

Referenced by CL_ClearState(), CL_DisconnectEx(), CL_ParseServerInfo(), CL_Reconnect_f(), CL_Shutdown(), QW_CL_Changing_f(), S_StopAllSounds_f(), S_UnloadAllSounds_f(), SV_SpawnServer(), Sys_Error(), and Sys_HandleCrash().

S_StopAllSounds_f()

void S_StopAllSounds_f

(

cmd_state_t *

cmd

)

Definition at line 1743 of file snd_main.c.

{
    S_StopAllSounds();
}

References S_StopAllSounds().

Referenced by S_Init().

S_StopChannel()

void S_StopChannel	(	unsigned int	channel_ind,
		qbool	lockmutex,
		qbool	freesfx )

Definition at line 1648 of file snd_main.c.

{
    channel_t *ch;
    sfx_t *sfx;
 
    if (channel_ind >= total_channels)
        return;
 
    // we have to lock an audio mutex to prevent crashes if an audio mixer
    // thread is currently mixing this channel
    // the SndSys_LockRenderBuffer function uses such a mutex in
    // threaded sound backends
    if (lockmutex && !simsound)
        SndSys_LockRenderBuffer();
    
    ch = &channels[channel_ind];
    sfx = ch->sfx;
    if (sfx != NULL)
    {
        if (sfx->fetcher != NULL && sfx->fetcher->stopchannel != NULL)
            sfx->fetcher->stopchannel(ch);
        ch->fetcher_data = NULL;
        ch->sfx = NULL;
        if (freesfx)
            S_FreeSfx(sfx, true);
    }
    if (lockmutex && !simsound)
        SndSys_UnlockRenderBuffer();
}

References channels, channel_t::fetcher_data, NULL, S_FreeSfx(), channel_t::sfx, simsound, SndSys_LockRenderBuffer(), SndSys_UnlockRenderBuffer(), and total_channels.

Referenced by CDAudio_Stop(), dpvsimpledecode_close(), jam_close(), libavw_close(), S_FreeSfx(), S_MixToBuffer(), S_PlaySfxOnChannel(), S_StopAllSounds(), S_StopSound(), and SND_PickChannel().

S_StopSound()

void S_StopSound	(	int	entnum,
		int	entchannel )

Definition at line 1698 of file snd_main.c.

{
    unsigned int i;
 
    for (i = 0; i < MAX_DYNAMIC_CHANNELS; i++)
        if (channels[i].entnum == entnum && channels[i].entchannel == entchannel)
        {
            S_StopChannel (i, true, false);
            return;
        }
}

References channels, entnum, i, MAX_DYNAMIC_CHANNELS, and S_StopChannel().

Referenced by CL_ParseServerMessage().

S_Terminate()

void S_Terminate

(

void

)

Definition at line 842 of file snd_main.c.

{
    S_Shutdown ();
#ifdef USEXMP
    XMP_CloseLibrary ();
#endif
    OGG_CloseLibrary ();
 
    // Free all SFXs
    while (known_sfx != NULL)
        S_FreeSfx (known_sfx, true);
 
    Cvar_SetValueQuick (&snd_initialized, false);
    Mem_FreePool (&snd_mempool);
}

References Cvar_SetValueQuick(), known_sfx, Mem_FreePool, NULL, OGG_CloseLibrary(), S_FreeSfx(), S_Shutdown(), snd_initialized, snd_mempool, and XMP_CloseLibrary().

Referenced by CL_Shutdown().

S_UnloadAllSounds_f()

void S_UnloadAllSounds_f

(

cmd_state_t *

cmd

)

Definition at line 864 of file snd_main.c.

{
    int i;
 
    // NOTE: we can't free all sounds if we are running a map (this frees sfx_t that are still referenced by precaches)
    // So, refuse to do this if we are connected.
    if(cls.state == ca_connected)
    {
        Con_Printf("snd_unloadallsounds would wreak havoc if you do that while connected!\n");
        return;
    }
 
    // stop any active sounds
    S_StopAllSounds();
 
    // because the ambient sounds will be freed, clear the pointers
    for (i = 0;i < (int)sizeof (ambient_sfxs) / (int)sizeof (ambient_sfxs[0]);i++)
        ambient_sfxs[i] = NULL;
 
    // now free all sounds
    while (known_sfx != NULL)
        S_FreeSfx (known_sfx, true);
}

References ambient_sfxs, ca_connected, cls, Con_Printf(), i, int(), known_sfx, NULL, S_FreeSfx(), S_StopAllSounds(), and client_static_t::state.

Referenced by FS_ChangeGameDirs(), and S_Init().

S_Update()

void S_Update

(

const matrix4x4_t *

listenermatrix

)

Definition at line 2061 of file snd_main.c.

{
    unsigned int i, j, k;
    channel_t *ch, *combine;
    matrix4x4_t rotatematrix;
 
    if (snd_renderbuffer == NULL || nosound.integer)
        return;
 
    // enable/disable sound on focus gain/loss
    snd_blocked = (snd_mutewhenidle.integer == 1 && !vid_activewindow)
               || (snd_mutewhenidle.integer == 2 && vid_hidden)
               || cls.timedemo;
 
    {
        double mindist_trans, maxdist_trans;
 
        spatialmin = snd_spatialization_min.value;
        spatialdiff = snd_spatialization_max.value - spatialmin;
 
        if(snd_spatialization_control.value)
        {
            spatialpower = snd_spatialization_power.value;
 
            if(spatialpower == 0)
            {
                spatialmethod = SPATIAL_LOG;
                mindist_trans = log(max(1, snd_spatialization_min_radius.value));
                maxdist_trans = log(max(1, snd_spatialization_max_radius.value));
            }
            else
            {
                spatialmethod = SPATIAL_POW;
                mindist_trans = pow(snd_spatialization_min_radius.value, spatialpower);
                maxdist_trans = pow(snd_spatialization_max_radius.value, spatialpower);
            }
 
            if(mindist_trans - maxdist_trans == 0)
            {
                spatialmethod = SPATIAL_THRESH;
                mindist_trans = snd_spatialization_min_radius.value;
            }
            else
            {
                spatialoffset = mindist_trans;
                spatialfactor = 1 / (maxdist_trans - mindist_trans);
            }
        }
        else
            spatialmethod = SPATIAL_NONE;
 
    }
 
    // If snd_swapstereo or snd_channellayout has changed, recompute the channel layout
    if (current_swapstereo != boolxor(snd_swapstereo.integer, v_flipped.integer) ||
        current_channellayout != snd_channellayout.integer)
        S_SetChannelLayout();
 
    Matrix4x4_Invert_Simple(&listener_basematrix, listenermatrix);
    Matrix4x4_OriginFromMatrix(listenermatrix, listener_origin);
    if (cl.worldmodel && cl.worldmodel->brush.FatPVS && cl.worldmodel->brush.num_pvsclusterbytes && cl.worldmodel->brush.PointInLeaf)
        listener_pvsbytes = cl.worldmodel->brush.FatPVS(cl.worldmodel, listener_origin, 2, &listener_pvs, snd_mempool, 0);
    else
    {
        if(listener_pvs)
        {
            Mem_Free(listener_pvs);
            listener_pvs = NULL;
        }
        listener_pvsbytes = 0;
    }
 
    // calculate the current matrices
    for (j = 0;j < SND_LISTENERS;j++)
    {
        Matrix4x4_CreateFromQuakeEntity(&rotatematrix, 0, 0, 0, 0, -snd_speakerlayout.listeners[j].yawangle, 0, 1);
        Matrix4x4_Concat(&listener_matrix[j], &rotatematrix, &listener_basematrix);
        // I think this should now do this:
        //   1. create a rotation matrix for rotating by e.g. -90 degrees CCW
        //      (note: the matrix will rotate the OBJECT, not the VIEWER, so its
        //       angle has to be taken negative)
        //   2. create a transform which first rotates and moves its argument
        //      into the player's view coordinates (using basematrix which is
        //      an inverted "absolute" listener matrix), then applies the
        //      rotation matrix for the ear
        // Isn't Matrix4x4_CreateFromQuakeEntity a bit misleading because this
        // does not actually refer to an entity?
    }
 
    // update general area ambient sound sources
    S_UpdateAmbientSounds ();
 
    combine = NULL;
    R_TimeReport("audioprep");
 
    // update spatialization for static and dynamic sounds
    cls.soundstats.totalsounds = 0;
    cls.soundstats.mixedsounds = 0;
    ch = channels+NUM_AMBIENTS;
    for (i=NUM_AMBIENTS ; i<total_channels; i++, ch++)
    {
        if (!ch->sfx)
            continue;
        cls.soundstats.totalsounds++;
 
        // respatialize channel
        SND_Spatialize(ch, i >= MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS);
 
        // try to combine static sounds with a previous channel of the same
        // sound effect so we don't mix five torches every frame
        if (i > MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS)
        {
            // no need to merge silent channels
            for (j = 0;j < SND_LISTENERS;j++)
                if (ch->volume[j])
                    break;
            if (j == SND_LISTENERS)
                continue;
            // if the last combine chosen isn't suitable, find a new one
            if (!(combine && combine != ch && combine->sfx == ch->sfx))
            {
                // search for one
                combine = NULL;
                for (j = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;j < i;j++)
                {
                    if (channels[j].sfx == ch->sfx)
                    {
                        combine = channels + j;
                        break;
                    }
                }
            }
            if (combine && combine != ch && combine->sfx == ch->sfx)
            {
                for (j = 0;j < SND_LISTENERS;j++)
                {
                    combine->volume[j] += ch->volume[j];
                    ch->volume[j] = 0;
                }
            }
        }
        for (k = 0;k < SND_LISTENERS;k++)
            if (ch->volume[k])
                break;
        if (k < SND_LISTENERS)
            cls.soundstats.mixedsounds++;
    }
    R_TimeReport("audiospatialize");
 
    // debugging output
    if (snd_show.integer)
        Con_Printf("----(%u)----\n", cls.soundstats.mixedsounds);
 
    S_PaintAndSubmit();
}

References boolxor, channels, cl, cls, Con_Printf(), current_channellayout, current_swapstereo, i, cvar_t::integer, listener_basematrix, listener_matrix, listener_origin, listener_pvs, listener_pvsbytes, speakerlayout_t::listeners, log(), Matrix4x4_Concat(), Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_Invert_Simple(), Matrix4x4_OriginFromMatrix(), max, MAX_DYNAMIC_CHANNELS, Mem_Free, cl_soundstats_t::mixedsounds, nosound, NULL, NUM_AMBIENTS, pow(), R_TimeReport(), S_PaintAndSubmit(), S_SetChannelLayout(), S_UpdateAmbientSounds(), channel_t::sfx, snd_blocked, snd_channellayout, SND_LISTENERS, snd_mempool, snd_mutewhenidle, snd_renderbuffer, snd_show, snd_spatialization_control, snd_spatialization_max, snd_spatialization_max_radius, snd_spatialization_min, snd_spatialization_min_radius, snd_spatialization_power, SND_Spatialize(), snd_speakerlayout, snd_swapstereo, client_static_t::soundstats, SPATIAL_LOG, SPATIAL_NONE, SPATIAL_POW, SPATIAL_THRESH, spatialdiff, spatialfactor, spatialmethod, spatialmin, spatialoffset, spatialpower, client_static_t::timedemo, total_channels, cl_soundstats_t::totalsounds, v_flipped, cvar_t::value, vid_activewindow, vid_hidden, channel_t::volume, client_state_t::worldmodel, and listener_t::yawangle.

Referenced by CL_Frame().

S_UpdateAmbientSounds()

static void S_UpdateAmbientSounds ( void )

static

Definition at line 1836 of file snd_main.c.

{
    int         i;
    float       vol;
    float       fade = (float)max(0.0, cl.time - cl.oldtime) * ambient_fade.value / 256.0f;
    int         ambient_channel;
    channel_t   *chan;
    unsigned char       ambientlevels[NUM_AMBIENTS];
    sfx_t       *sfx;
 
    memset(ambientlevels, 0, sizeof(ambientlevels));
    if (cl.worldmodel && cl.worldmodel->brush.AmbientSoundLevelsForPoint)
        cl.worldmodel->brush.AmbientSoundLevelsForPoint(cl.worldmodel, listener_origin, ambientlevels, sizeof(ambientlevels));
 
 
    // Calc ambient sound levels
    S_SetUnderwaterIntensity();
 
    for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++)
    {
        chan = &channels[ambient_channel];
        sfx = chan->sfx; // fetch the volatile variable
        if (sfx == NULL || sfx->fetcher == NULL)
            continue;
 
        i = ambientlevels[ambient_channel];
        if (i < 8)
            i = 0;
        vol = i * (1.0f / 256.0f);
 
        // Don't adjust volume too fast
        if (chan->basevolume < vol)
        {
            chan->basevolume += fade;
            if (chan->basevolume > vol)
                chan->basevolume = vol;
        }
        else if (chan->basevolume > vol)
        {
            chan->basevolume -= fade;
            if (chan->basevolume < vol)
                chan->basevolume = vol;
        }
 
        if (snd_spatialization_prologic.integer != 0)
        {
            chan->volume[0] = chan->basevolume * ambient_level.value * volume.value * mastervolume.value * snd_speakerlayout.listeners[0].ambientvolume * sqrt(0.5);
            chan->volume[1] = chan->basevolume * ambient_level.value * volume.value * mastervolume.value * snd_speakerlayout.listeners[1].ambientvolume * sqrt(0.5);
            for (i = 2;i < SND_LISTENERS;i++)
                chan->volume[i] = 0.0f;
        }
        else
        {
            for (i = 0;i < SND_LISTENERS;i++)
                chan->volume[i] = chan->basevolume * ambient_level.value * volume.value * mastervolume.value * snd_speakerlayout.listeners[i].ambientvolume;
        }
    }
}

References ambient_fade, ambient_level, listener_t::ambientvolume, channel_t::basevolume, channels, cl, float, i, cvar_t::integer, listener_origin, speakerlayout_t::listeners, mastervolume, max, NULL, NUM_AMBIENTS, client_state_t::oldtime, S_SetUnderwaterIntensity(), channel_t::sfx, SND_LISTENERS, snd_spatialization_prologic, snd_speakerlayout, sqrt(), client_state_t::time, cvar_t::value, channel_t::volume, volume, and client_state_t::worldmodel.

Referenced by S_Update().

SND_PickChannel()

static channel_t * SND_PickChannel ( int entnum, int entchannel )

static

Definition at line 1118 of file snd_main.c.

{
    int ch_idx;
    int first_to_die;
    int first_life_left, life_left;
    channel_t* ch;
    sfx_t *sfx; // use this instead of ch->sfx->, because that is volatile.
 
// Check for replacement sound, or find the best one to replace
    first_to_die = -1;
    first_life_left = 0x7fffffff;
 
    // entity channels try to replace the existing sound on the channel
    // channels <= 0 are autochannels
    if (IS_CHAN_SINGLE(entchannel))
    {
        for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++)
        {
            ch = &channels[ch_idx];
            if (ch->entnum == entnum && ch->entchannel == entchannel)
            {
                // always override sound from same entity
                S_StopChannel (ch_idx, true, false);
                return &channels[ch_idx];
            }
        }
    }
 
    // there was no channel to override, so look for the first empty one
    for (ch_idx=NUM_AMBIENTS ; ch_idx < NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS ; ch_idx++)
    {
        ch = &channels[ch_idx];
        sfx = ch->sfx; // fetch the volatile variable
        if (!sfx)
        {
            // no sound on this channel
            first_to_die = ch_idx;
            goto emptychan_found;
        }
 
        // don't let monster sounds override player sounds
        if ((ch->entnum == cl.viewentity || ch->entnum == CL_VM_GetViewEntity()) && !(entnum == cl.viewentity || entnum == CL_VM_GetViewEntity()))
            continue;
 
        // don't override looped sounds
        if ((ch->flags & CHANNELFLAG_FORCELOOP) || sfx->loopstart < sfx->total_length)
            continue;
        life_left = (int)((double)sfx->total_length - ch->position);
 
        if (life_left < first_life_left)
        {
            first_life_left = life_left;
            first_to_die = ch_idx;
        }
    }
 
    if (first_to_die == -1)
        return NULL;
    
    S_StopChannel (first_to_die, true, false);
 
emptychan_found:
    return &channels[first_to_die];
}

References CHANNELFLAG_FORCELOOP, channels, cl, CL_VM_GetViewEntity(), channel_t::entchannel, channel_t::entnum, entnum, channel_t::flags, int(), IS_CHAN_SINGLE, MAX_DYNAMIC_CHANNELS, NULL, NUM_AMBIENTS, channel_t::position, S_StopChannel(), channel_t::sfx, and client_state_t::viewentity.

Referenced by S_StartSound_StartPosition_Flags().

SND_Spatialize()

static void SND_Spatialize ( channel_t * ch, qbool isstatic )

static

Definition at line 1503 of file snd_main.c.

{
    sfx_t *sfx = ch->sfx;
    SND_Spatialize_WithSfx(ch, isstatic, sfx);
}

References channel_t::sfx, and SND_Spatialize_WithSfx().

Referenced by S_StartSound_StartPosition_Flags(), and S_Update().

SND_Spatialize_WithSfx()

static void SND_Spatialize_WithSfx ( channel_t * ch, qbool isstatic, sfx_t * sfx )

static

Definition at line 1191 of file snd_main.c.

{
    int i;
    double f;
    float angle_side, angle_front, angle_factor, mixspeed;
    vec_t dist, mastervol, intensity;
    vec3_t source_vec;
    char vabuf[1024];
 
    // update sound origin if we know about the entity
    if (ch->entnum > 0 && cls.state == ca_connected && cl_gameplayfix_soundsmovewithentities.integer)
    {
        if (ch->entnum >= MAX_EDICTS)
        {
            //Con_Printf("-- entnum %i origin %f %f %f neworigin %f %f %f\n", ch->entnum, ch->origin[0], ch->origin[1], ch->origin[2], cl.entities[ch->entnum].state_current.origin[0], cl.entities[ch->entnum].state_current.origin[1], cl.entities[ch->entnum].state_current.origin[2]);
 
            if (CLVM_prog->loaded && ch->entnum > MAX_EDICTS)
                if (!CL_VM_GetEntitySoundOrigin(ch->entnum, ch->origin))
                    ch->entnum = MAX_EDICTS; // entity was removed, disown sound
        }
        else if (cl.entities[ch->entnum].state_current.active)
        {
            model_t *model;
            //Con_Printf("-- entnum %i origin %f %f %f neworigin %f %f %f\n", ch->entnum, ch->origin[0], ch->origin[1], ch->origin[2], cl.entities[ch->entnum].state_current.origin[0], cl.entities[ch->entnum].state_current.origin[1], cl.entities[ch->entnum].state_current.origin[2]);
            model = CL_GetModelByIndex(cl.entities[ch->entnum].state_current.modelindex);
            if (model && model->soundfromcenter)
                VectorMAM(0.5f, cl.entities[ch->entnum].render.mins, 0.5f, cl.entities[ch->entnum].render.maxs, ch->origin);
            else
                Matrix4x4_OriginFromMatrix(&cl.entities[ch->entnum].render.matrix, ch->origin);
        }
        else if (CLVM_prog->loaded && cl.csqc_server2csqcentitynumber[ch->entnum])
        {
            //Con_Printf("-- entnum %i (client %i) origin %f %f %f neworigin %f %f %f\n", ch->entnum, cl.csqc_server2csqcentitynumber[ch->entnum], ch->origin[0], ch->origin[1], ch->origin[2], cl.entities[ch->entnum].state_current.origin[0], cl.entities[ch->entnum].state_current.origin[1], cl.entities[ch->entnum].state_current.origin[2]);
 
            if (!CL_VM_GetEntitySoundOrigin(cl.csqc_server2csqcentitynumber[ch->entnum] + MAX_EDICTS, ch->origin))
                ch->entnum = MAX_EDICTS; // entity was removed, disown sound
        }
    }
 
    mastervol = ch->basevolume;
    mixspeed = ch->basespeed;
 
    // TODO: implement doppler based on origin change relative to viewer and time of recent origin changes
 
    // Adjust volume of static sounds
    if (isstatic)
        mastervol *= snd_staticvolume.value;
    else if(!(ch->flags & CHANNELFLAG_FULLVOLUME)) // same as SND_PaintChannel uses
    {
        // old legacy separated cvars
        if(ch->entnum >= MAX_EDICTS)
        {
            switch(ch->entchannel)
            {
                case 0: mastervol *= snd_csqcchannel0volume.value; break;
                case 1: mastervol *= snd_csqcchannel1volume.value; break;
                case 2: mastervol *= snd_csqcchannel2volume.value; break;
                case 3: mastervol *= snd_csqcchannel3volume.value; break;
                case 4: mastervol *= snd_csqcchannel4volume.value; break;
                case 5: mastervol *= snd_csqcchannel5volume.value; break;
                case 6: mastervol *= snd_csqcchannel6volume.value; break;
                case 7: mastervol *= snd_csqcchannel7volume.value; break;
                default:                                           break;
            }
        }
        else if(ch->entnum == 0)
        {
            switch(ch->entchannel)
            {
                case 0: mastervol *= snd_worldchannel0volume.value; break;
                case 1: mastervol *= snd_worldchannel1volume.value; break;
                case 2: mastervol *= snd_worldchannel2volume.value; break;
                case 3: mastervol *= snd_worldchannel3volume.value; break;
                case 4: mastervol *= snd_worldchannel4volume.value; break;
                case 5: mastervol *= snd_worldchannel5volume.value; break;
                case 6: mastervol *= snd_worldchannel6volume.value; break;
                case 7: mastervol *= snd_worldchannel7volume.value; break;
                default:                                            break;
            }
        }
        else if(ch->entnum > 0 && ch->entnum <= cl.maxclients)
        {
            switch(ch->entchannel)
            {
                case 0: mastervol *= snd_playerchannel0volume.value; break;
                case 1: mastervol *= snd_playerchannel1volume.value; break;
                case 2: mastervol *= snd_playerchannel2volume.value; break;
                case 3: mastervol *= snd_playerchannel3volume.value; break;
                case 4: mastervol *= snd_playerchannel4volume.value; break;
                case 5: mastervol *= snd_playerchannel5volume.value; break;
                case 6: mastervol *= snd_playerchannel6volume.value; break;
                case 7: mastervol *= snd_playerchannel7volume.value; break;
                default:                                             break;
            }
        }
        else
        {
            switch(ch->entchannel)
            {
                case 0: mastervol *= snd_entchannel0volume.value; break;
                case 1: mastervol *= snd_entchannel1volume.value; break;
                case 2: mastervol *= snd_entchannel2volume.value; break;
                case 3: mastervol *= snd_entchannel3volume.value; break;
                case 4: mastervol *= snd_entchannel4volume.value; break;
                case 5: mastervol *= snd_entchannel5volume.value; break;
                case 6: mastervol *= snd_entchannel6volume.value; break;
                case 7: mastervol *= snd_entchannel7volume.value; break;
                default:                                          break;
            }
        }
 
        switch(ch->entchannel)
        {
            case 0:  mastervol *= snd_channel0volume.value; break;
            case 1:  mastervol *= snd_channel1volume.value; break;
            case 2:  mastervol *= snd_channel2volume.value; break;
            case 3:  mastervol *= snd_channel3volume.value; break;
            case 4:  mastervol *= snd_channel4volume.value; break;
            case 5:  mastervol *= snd_channel5volume.value; break;
            case 6:  mastervol *= snd_channel6volume.value; break;
            case 7:  mastervol *= snd_channel7volume.value; break;
            default: mastervol *= Cvar_VariableValueOr(&cvars_all, va(vabuf, sizeof(vabuf), "snd_channel%dvolume", CHAN_ENGINE2CVAR(ch->entchannel)), 1.0, ~0); break;
        }
    }
 
    // If this channel does not manage its own volume (like CD tracks)
    if (!(ch->flags & CHANNELFLAG_FULLVOLUME))
        mastervol *= volume.value;
 
    if(snd_maxchannelvolume.value > 0)
    {
        // clamp HERE to allow to go at most 10dB past mastervolume (before clamping), when mastervolume < -10dB (so relative volumes don't get too messy)
        mastervol = bound(0.0f, mastervol, 10.0f * snd_maxchannelvolume.value);
    }
 
    // always apply "master"
    mastervol *= mastervolume.value;
 
    // add in ReplayGain very late; prevent clipping when close
    if(sfx)
    if(sfx->volume_peak > 0)
    {
        // Replaygain support
        // Con_DPrintf("Setting volume on ReplayGain-enabled track... %f -> ", fvol);
        mastervol *= sfx->volume_mult;
        if(snd_maxchannelvolume.value > 0)
        {
            if(mastervol * sfx->volume_peak > snd_maxchannelvolume.value)
                mastervol = snd_maxchannelvolume.value / sfx->volume_peak;
        }
        // Con_DPrintf("%f\n", fvol);
    }
 
    if(snd_maxchannelvolume.value > 0)
    {
        // clamp HERE to keep relative volumes of the channels correct
        mastervol = min(mastervol, snd_maxchannelvolume.value);
    }
 
    mastervol = max(0.0f, mastervol);
 
    ch->mixspeed = mixspeed;
 
    // anything coming from the view entity will always be full volume
    // LadyHavoc: make sounds with ATTN_NONE have no spatialization
    if (ch->entnum == cl.viewentity || ch->entnum == CL_VM_GetViewEntity() || ch->distfade == 0)
    {
        ch->prologic_invert = 1;
        if (snd_spatialization_prologic.integer != 0)
        {
            ch->volume[0] = mastervol * snd_speakerlayout.listeners[0].ambientvolume * sqrt(0.5);
            ch->volume[1] = mastervol * snd_speakerlayout.listeners[1].ambientvolume * sqrt(0.5);
            for (i = 2;i < SND_LISTENERS;i++)
                ch->volume[i] = 0;
        }
        else
        {
            for (i = 0;i < SND_LISTENERS;i++)
                ch->volume[i] = mastervol * snd_speakerlayout.listeners[i].ambientvolume;
        }
    }
    else
    {
        // calculate stereo seperation and distance attenuation
        VectorSubtract(listener_origin, ch->origin, source_vec);
        dist = VectorLength(source_vec);
        f = dist * ch->distfade;
 
        f =
            ((snd_attenuation_exponent.value == 0) ? 1.0 : pow(1.0 - min(1.0, f), (double)snd_attenuation_exponent.value))
            *
            ((snd_attenuation_decibel.value == 0) ? 1.0 : pow(0.1, 0.1 * snd_attenuation_decibel.value * f));
 
        intensity = mastervol * f;
        if (intensity > 0)
        {
            qbool occluded = false;
            if (snd_spatialization_occlusion.integer)
            {
                if(snd_spatialization_occlusion.integer & 1)
                    if(listener_pvs && cl.worldmodel)
                    {
                        int cluster = cl.worldmodel->brush.PointInLeaf(cl.worldmodel, ch->origin)->clusterindex;
                        if(cluster >= 0 && cluster < 8 * listener_pvsbytes && !CHECKPVSBIT(listener_pvs, cluster))
                            occluded = true;
                    }
 
                if(snd_spatialization_occlusion.integer & 2)
                    if(!occluded)
                        if(cl.worldmodel && cl.worldmodel->brush.TraceLineOfSight && !cl.worldmodel->brush.TraceLineOfSight(cl.worldmodel, listener_origin, ch->origin, ch->origin, ch->origin))
                            occluded = true;
            }
            if(occluded)
                intensity *= 0.5f;
 
            ch->prologic_invert = 1;
            if (snd_spatialization_prologic.integer != 0)
            {
                if (dist == 0)
                    angle_factor = 0.5f;
                else
                {
                    Matrix4x4_Transform(&listener_basematrix, ch->origin, source_vec);
                    VectorNormalize(source_vec);
 
                    switch(spatialmethod)
                    {
                        case SPATIAL_LOG:
                            if(dist == 0)
                                f = spatialmin + spatialdiff * (spatialfactor < 0); // avoid log(0), but do the right thing
                            else
                                f = spatialmin + spatialdiff * bound(0, (log(dist) - spatialoffset) * spatialfactor, 1);
                            VectorScale(source_vec, f, source_vec);
                            break;
                        case SPATIAL_POW:
                            f = (pow(dist, spatialpower) - spatialoffset) * spatialfactor;
                            f = spatialmin + spatialdiff * bound(0, f, 1);
                            VectorScale(source_vec, f, source_vec);
                            break;
                        case SPATIAL_THRESH:
                            f = spatialmin + spatialdiff * (dist < spatialoffset);
                            VectorScale(source_vec, f, source_vec);
                            break;
                        case SPATIAL_NONE:
                        default:
                            break;
                    }
 
                    // the z axis needs to be removed and normalized because otherwise the volume would get lower as the sound source goes higher or lower then normal
                    source_vec[2] = 0;
                    VectorNormalize(source_vec);
                    angle_side = acos(source_vec[0]) / M_PI * 180;  // angle between 0 and 180 degrees
                    angle_front = asin(source_vec[1]) / M_PI * 180; // angle between -90 and 90 degrees
                    if (angle_side > snd_spatialization_prologic_frontangle.value)
                    {
                        ch->prologic_invert = -1;   // this will cause the right channel to do a 180 degrees phase shift (turning the sound wave upside down),
                                                    // but the best would be 90 degrees phase shift left and a -90 degrees phase shift right.
                        angle_factor = (angle_side - snd_spatialization_prologic_frontangle.value) / (360 - 2 * snd_spatialization_prologic_frontangle.value);
                        // angle_factor is between 0 and 1 and represents the angle range from the front left, to all the surround speakers (amount may vary,
                        // 1 in prologic I 2 in prologic II and 3 or 4 in prologic IIx) to the front right speaker.
                        if (angle_front > 0)
                            angle_factor = 1 - angle_factor;
                    }
                    else
                        angle_factor = angle_front / snd_spatialization_prologic_frontangle.value / 2.0 + 0.5;
                        //angle_factor is between 0 and 1 and represents the angle range from the front left to the center to the front right speaker
                }
 
                ch->volume[0] = intensity * sqrt(angle_factor);
                ch->volume[1] = intensity * sqrt(1 - angle_factor);
                for (i = 2;i < SND_LISTENERS;i++)
                    ch->volume[i] = 0;
            }
            else
            {
                for (i = 0;i < SND_LISTENERS;i++)
                {
                    Matrix4x4_Transform(&listener_matrix[i], ch->origin, source_vec);
                    VectorNormalize(source_vec);
 
                    switch(spatialmethod)
                    {
                        case SPATIAL_LOG:
                            if(dist == 0)
                                f = spatialmin + spatialdiff * (spatialfactor < 0); // avoid log(0), but do the right thing
                            else
                                f = spatialmin + spatialdiff * bound(0, (log(dist) - spatialoffset) * spatialfactor, 1);
                            VectorScale(source_vec, f, source_vec);
                            break;
                        case SPATIAL_POW:
                            f = (pow(dist, spatialpower) - spatialoffset) * spatialfactor;
                            f = spatialmin + spatialdiff * bound(0, f, 1);
                            VectorScale(source_vec, f, source_vec);
                            break;
                        case SPATIAL_THRESH:
                            f = spatialmin + spatialdiff * (dist < spatialoffset);
                            VectorScale(source_vec, f, source_vec);
                            break;
                        case SPATIAL_NONE:
                        default:
                            break;
                    }
 
                    ch->volume[i] = intensity * max(0, source_vec[0] * snd_speakerlayout.listeners[i].dotscale + snd_speakerlayout.listeners[i].dotbias);
                }
            }
        }
        else
            for (i = 0;i < SND_LISTENERS;i++)
                ch->volume[i] = 0;
    }
}

References entity_state_t::active, listener_t::ambientvolume, channel_t::basespeed, channel_t::basevolume, bound, ca_connected, CHAN_ENGINE2CVAR, CHANNELFLAG_FULLVOLUME, CHECKPVSBIT, cl, cl_gameplayfix_soundsmovewithentities, CL_GetModelByIndex(), CL_VM_GetEntitySoundOrigin(), CL_VM_GetViewEntity(), cls, CLVM_prog, client_state_t::csqc_server2csqcentitynumber, Cvar_VariableValueOr(), cvars_all, channel_t::distfade, listener_t::dotbias, listener_t::dotscale, channel_t::entchannel, client_state_t::entities, channel_t::entnum, f, channel_t::flags, i, cvar_t::integer, intensity, listener_basematrix, listener_matrix, listener_origin, listener_pvs, listener_pvsbytes, speakerlayout_t::listeners, log(), M_PI, mastervolume, entity_render_t::matrix, Matrix4x4_OriginFromMatrix(), Matrix4x4_Transform(), max, MAX_EDICTS, client_state_t::maxclients, entity_render_t::maxs, min, entity_render_t::mins, channel_t::mixspeed, model, entity_state_t::modelindex, channel_t::origin, pow(), channel_t::prologic_invert, entity_t::render, snd_attenuation_decibel, snd_attenuation_exponent, snd_channel0volume, snd_channel1volume, snd_channel2volume, snd_channel3volume, snd_channel4volume, snd_channel5volume, snd_channel6volume, snd_channel7volume, snd_csqcchannel0volume, snd_csqcchannel1volume, snd_csqcchannel2volume, snd_csqcchannel3volume, snd_csqcchannel4volume, snd_csqcchannel5volume, snd_csqcchannel6volume, snd_csqcchannel7volume, snd_entchannel0volume, snd_entchannel1volume, snd_entchannel2volume, snd_entchannel3volume, snd_entchannel4volume, snd_entchannel5volume, snd_entchannel6volume, snd_entchannel7volume, SND_LISTENERS, snd_maxchannelvolume, snd_playerchannel0volume, snd_playerchannel1volume, snd_playerchannel2volume, snd_playerchannel3volume, snd_playerchannel4volume, snd_playerchannel5volume, snd_playerchannel6volume, snd_playerchannel7volume, snd_spatialization_occlusion, snd_spatialization_prologic, snd_spatialization_prologic_frontangle, snd_speakerlayout, snd_staticvolume, snd_worldchannel0volume, snd_worldchannel1volume, snd_worldchannel2volume, snd_worldchannel3volume, snd_worldchannel4volume, snd_worldchannel5volume, snd_worldchannel6volume, snd_worldchannel7volume, SPATIAL_LOG, SPATIAL_NONE, SPATIAL_POW, SPATIAL_THRESH, spatialdiff, spatialfactor, spatialmethod, spatialmin, spatialoffset, spatialpower, sqrt(), client_static_t::state, entity_t::state_current, va(), cvar_t::value, VectorLength, VectorMAM, VectorNormalize, VectorScale, VectorSubtract, client_state_t::viewentity, channel_t::volume, volume, and client_state_t::worldmodel.

Referenced by S_PlaySfxOnChannel(), and SND_Spatialize().

Variable Documentation

_snd_mixahead

cvar_t _snd_mixahead = {CF_CLIENT | CF_ARCHIVE, "_snd_mixahead", "0.15", "how much sound to mix ahead of time"}

Definition at line 190 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "_snd_mixahead", "0.15", "how much sound to mix ahead of time"};

Referenced by S_Init(), and S_PaintAndSubmit().

ambient_fade

cvar_t ambient_fade = {CF_CLIENT, "ambient_fade", "100", "rate of volume fading when moving from one environment to another"}

static

Definition at line 240 of file snd_main.c.

{CF_CLIENT, "ambient_fade", "100", "rate of volume fading when moving from one environment to another"};

Referenced by S_Init(), and S_UpdateAmbientSounds().

ambient_level

cvar_t ambient_level = {CF_CLIENT, "ambient_level", "0.3", "volume of environment noises (water and wind)"}

static

Definition at line 239 of file snd_main.c.

{CF_CLIENT, "ambient_level", "0.3", "volume of environment noises (water and wind)"};

Referenced by S_Init(), and S_UpdateAmbientSounds().

ambient_names

const char* ambient_names[2] = { "sound/ambience/water1.wav", "sound/ambience/wind2.wav" }

static

Definition at line 259 of file snd_main.c.

{ "sound/ambience/water1.wav", "sound/ambience/wind2.wav" };

Referenced by S_ClearUsed().

ambient_sfxs

sfx_t* ambient_sfxs[2] = { NULL, NULL }

static

Definition at line 258 of file snd_main.c.

{ NULL, NULL };

Referenced by S_ClearUsed(), and S_UnloadAllSounds_f().

bgmvolume

cvar_t bgmvolume = {CF_CLIENT | CF_ARCHIVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"}

Definition at line 165 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"};

Referenced by CDAudio_Play_byName(), CDAudio_Update(), CL_ParseServerMessage(), M_Menu_Options_AdjustSliders(), M_Options_Draw(), and S_Init().

changevolume_sfx

sfx_t changevolume_sfx = {""}

Definition at line 894 of file snd_main.c.

{""};

Referenced by S_FindName(), S_IsSoundPrecached(), and S_StartSound_StartPosition_Flags().

channels

channel_t channels[MAX_CHANNELS]

Definition at line 128 of file snd_main.c.

Referenced by S_ClearUsed(), S_FreeSfx(), S_GetChannelPosition(), S_GetEntChannelPosition(), S_Init(), S_LocalSoundEx(), S_MixToBuffer(), S_PauseGameSounds(), S_Play_Common(), S_PlaySfxOnChannel(), S_SetChannelFlag(), S_SetChannelLayout(), S_SetChannelSpeed(), S_SetChannelVolume(), S_StartSound_StartPosition_Flags(), S_StaticSound(), S_StopAllSounds(), S_StopChannel(), S_StopSound(), S_Update(), S_UpdateAmbientSounds(), and SND_PickChannel().

cl_gameplayfix_soundsmovewithentities

cvar_t cl_gameplayfix_soundsmovewithentities

extern

Definition at line 174 of file cl_parse.c.

{CF_CLIENT, "cl_gameplayfix_soundsmovewithentities", "1", "causes sounds made by lifts, players, projectiles, and any other entities, to move with the entity, so for example a rocket noise follows the rocket rather than staying at the starting position"};

Referenced by CL_Parse_Init(), and SND_Spatialize_WithSfx().

current_channellayout

int current_channellayout = SND_CHANNELLAYOUT_AUTO

static

Definition at line 157 of file snd_main.c.

Referenced by S_SetChannelLayout(), and S_Update().

current_channellayout_used

int current_channellayout_used = SND_CHANNELLAYOUT_AUTO

static

Definition at line 158 of file snd_main.c.

Referenced by S_SetChannelLayout(), and S_Startup().

current_swapstereo

bool current_swapstereo = false

static

Definition at line 156 of file snd_main.c.

Referenced by S_SetChannelLayout(), and S_Update().

extrasoundtime

unsigned int extrasoundtime = 0

static

Definition at line 134 of file snd_main.c.

Referenced by S_PaintAndSubmit(), and S_Startup().

known_sfx

sfx_t* known_sfx = NULL

static

Definition at line 147 of file snd_main.c.

Referenced by S_ClearUsed(), S_FindName(), S_FreeSfx(), S_Init(), S_PurgeUnused(), S_SoundList_f(), S_Terminate(), and S_UnloadAllSounds_f().

listener_basematrix

matrix4x4_t listener_basematrix

Definition at line 140 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

listener_matrix

matrix4x4_t listener_matrix[SND_LISTENERS]

Definition at line 143 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

listener_origin

vec3_t listener_origin

Definition at line 139 of file snd_main.c.

Referenced by S_Play_Common(), S_Update(), S_UpdateAmbientSounds(), and SND_Spatialize_WithSfx().

listener_pvs

unsigned char* listener_pvs = NULL

static

Definition at line 141 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

listener_pvsbytes

int listener_pvsbytes = 0

static

Definition at line 142 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

mastervolume

cvar_t mastervolume = {CF_CLIENT | CF_ARCHIVE, "mastervolume", "0.7", "master volume"}

Definition at line 176 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "mastervolume", "0.7", "master volume"};

Referenced by S_Init(), S_UpdateAmbientSounds(), and SND_Spatialize_WithSfx().

nosound

cvar_t nosound = {CF_CLIENT, "nosound", "0", "disables sound"}

static

Definition at line 237 of file snd_main.c.

{CF_CLIENT, "nosound", "0", "disables sound"};

Referenced by S_Init(), S_LocalSoundEx(), S_PaintAndSubmit(), S_PrecacheSound(), S_StartSound_StartPosition_Flags(), S_StaticSound(), and S_Update().

oldpaintedtime

unsigned int oldpaintedtime = 0

static

Definition at line 133 of file snd_main.c.

Referenced by S_Shutdown(), and S_Startup().

simsound

qbool simsound = false

If simsound is true, the sound card is not initialized and no sound is submitted to it.

More generally, all arch-dependent operations are skipped or emulated. Used for isolating performance in the renderer.

Definition at line 149 of file snd_main.c.

Referenced by S_Init(), S_PaintAndSubmit(), S_Shutdown(), S_Startup(), S_StopAllSounds(), and S_StopChannel().

snd_attenuation_decibel

cvar_t snd_attenuation_decibel = {CF_CLIENT | CF_ARCHIVE, "snd_attenuation_decibel", "0", "Decibel sound attenuation per sound radius distance"}

Definition at line 180 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_attenuation_decibel", "0", "Decibel sound attenuation per sound radius distance"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_attenuation_exponent

cvar_t snd_attenuation_exponent = {CF_CLIENT | CF_ARCHIVE, "snd_attenuation_exponent", "1", "Exponent of (1-radius) in sound attenuation formula"}

Definition at line 179 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_attenuation_exponent", "1", "Exponent of (1-radius) in sound attenuation formula"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_blocked

bool snd_blocked = false

When true, we submit silence to the audio device.

Definition at line 155 of file snd_main.c.

Referenced by Buffer_Callback(), S_PaintAndSubmit(), and S_Update().

snd_bufferlength

cvar_t snd_bufferlength = {CF_CLIENT | CF_ARCHIVE, "snd_bufferlength", "20", "Desired length of the SDL2 audio buffer in milliseconds, smaller values reduce latency but can lead to underflow if the system is heavily loaded. Affects only how many sample frames are requested (which will be a power of 2 between 512 and 8192 inclusive)"}

Definition at line 248 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_bufferlength", "20", "Desired length of the SDL2 audio buffer in milliseconds, smaller values reduce latency but can lead to underflow if the system is heavily loaded. Affects only how many sample frames are requested (which will be a power of 2 between 512 and 8192 inclusive)"};

Referenced by S_Init(), and SndSys_Init().

snd_channel0volume

cvar_t snd_channel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel0volume", "1", "volume multiplier of the auto-allocate entity channel"}

Definition at line 228 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel0volume", "1", "volume multiplier of the auto-allocate entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel1volume

cvar_t snd_channel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel1volume", "1", "volume multiplier of the 1st entity channel"}

Definition at line 229 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel1volume", "1", "volume multiplier of the 1st entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel2volume

cvar_t snd_channel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel2volume", "1", "volume multiplier of the 2nd entity channel"}

Definition at line 230 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel2volume", "1", "volume multiplier of the 2nd entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel3volume

cvar_t snd_channel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel3volume", "1", "volume multiplier of the 3rd entity channel"}

Definition at line 231 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel3volume", "1", "volume multiplier of the 3rd entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel4volume

cvar_t snd_channel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel4volume", "1", "volume multiplier of the 4th entity channel"}

Definition at line 232 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel4volume", "1", "volume multiplier of the 4th entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel5volume

cvar_t snd_channel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel5volume", "1", "volume multiplier of the 5th entity channel"}

Definition at line 233 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel5volume", "1", "volume multiplier of the 5th entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel6volume

cvar_t snd_channel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel6volume", "1", "volume multiplier of the 6th entity channel"}

Definition at line 234 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel6volume", "1", "volume multiplier of the 6th entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channel7volume

cvar_t snd_channel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel7volume", "1", "volume multiplier of the 7th entity channel"}

Definition at line 235 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channel7volume", "1", "volume multiplier of the 7th entity channel"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_channellayout

cvar_t snd_channellayout = {CF_CLIENT, "snd_channellayout", "0", "channel layout. Can be 0 (auto - snd_restart needed), 1 (standard layout), or 2 (ALSA layout)"}

Definition at line 170 of file snd_main.c.

{CF_CLIENT, "snd_channellayout", "0", "channel layout. Can be 0 (auto - snd_restart needed), 1 (standard layout), or 2 (ALSA layout)"};

Referenced by S_Init(), S_SetChannelLayout(), S_Update(), and SndSys_Init().

snd_channels

cvar_t snd_channels = {CF_CLIENT | CF_ARCHIVE, "snd_channels", "2", "number of channels for the sound output (2 for stereo; up to 8 supported for 3D sound)"}

static

Definition at line 247 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_channels", "2", "number of channels for the sound output (2 for stereo; up to 8 supported for 3D sound)"};

Referenced by S_Init(), and S_Startup().

snd_csqcchannel0volume

cvar_t snd_csqcchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel0volume", "1", "volume multiplier of the auto-allocate entity channel CSQC entities (DEPRECATED)"}

Definition at line 220 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel0volume", "1", "volume multiplier of the auto-allocate entity channel CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel1volume

cvar_t snd_csqcchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel1volume", "1", "volume multiplier of the 1st entity channel of CSQC entities (DEPRECATED)"}

Definition at line 221 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel1volume", "1", "volume multiplier of the 1st entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel2volume

cvar_t snd_csqcchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel2volume", "1", "volume multiplier of the 2nd entity channel of CSQC entities (DEPRECATED)"}

Definition at line 222 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel2volume", "1", "volume multiplier of the 2nd entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel3volume

cvar_t snd_csqcchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel3volume", "1", "volume multiplier of the 3rd entity channel of CSQC entities (DEPRECATED)"}

Definition at line 223 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel3volume", "1", "volume multiplier of the 3rd entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel4volume

cvar_t snd_csqcchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel4volume", "1", "volume multiplier of the 4th entity channel of CSQC entities (DEPRECATED)"}

Definition at line 224 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel4volume", "1", "volume multiplier of the 4th entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel5volume

cvar_t snd_csqcchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel5volume", "1", "volume multiplier of the 5th entity channel of CSQC entities (DEPRECATED)"}

Definition at line 225 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel5volume", "1", "volume multiplier of the 5th entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel6volume

cvar_t snd_csqcchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel6volume", "1", "volume multiplier of the 6th entity channel of CSQC entities (DEPRECATED)"}

Definition at line 226 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel6volume", "1", "volume multiplier of the 6th entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_csqcchannel7volume

cvar_t snd_csqcchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel7volume", "1", "volume multiplier of the 7th entity channel of CSQC entities (DEPRECATED)"}

Definition at line 227 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel7volume", "1", "volume multiplier of the 7th entity channel of CSQC entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel0volume

cvar_t snd_entchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of regular entities (DEPRECATED)"}

Definition at line 196 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel1volume

cvar_t snd_entchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel1volume", "1", "volume multiplier of the 1st entity channel of regular entities (DEPRECATED)"}

Definition at line 197 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel1volume", "1", "volume multiplier of the 1st entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel2volume

cvar_t snd_entchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel2volume", "1", "volume multiplier of the 2nd entity channel of regular entities (DEPRECATED)"}

Definition at line 198 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel2volume", "1", "volume multiplier of the 2nd entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel3volume

cvar_t snd_entchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel3volume", "1", "volume multiplier of the 3rd entity channel of regular entities (DEPRECATED)"}

Definition at line 199 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel3volume", "1", "volume multiplier of the 3rd entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel4volume

cvar_t snd_entchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel4volume", "1", "volume multiplier of the 4th entity channel of regular entities (DEPRECATED)"}

Definition at line 200 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel4volume", "1", "volume multiplier of the 4th entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel5volume

cvar_t snd_entchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel5volume", "1", "volume multiplier of the 5th entity channel of regular entities (DEPRECATED)"}

Definition at line 201 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel5volume", "1", "volume multiplier of the 5th entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel6volume

cvar_t snd_entchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel6volume", "1", "volume multiplier of the 6th entity channel of regular entities (DEPRECATED)"}

Definition at line 202 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel6volume", "1", "volume multiplier of the 6th entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_entchannel7volume

cvar_t snd_entchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel7volume", "1", "volume multiplier of the 7th entity channel of regular entities (DEPRECATED)"}

Definition at line 203 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_entchannel7volume", "1", "volume multiplier of the 7th entity channel of regular entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_identicalsoundrandomization_tics

cvar_t snd_identicalsoundrandomization_tics = {CF_CLIENT, "snd_identicalsoundrandomization_tics", "0", "if nonzero, how many tics to limit sound randomization as defined by snd_identicalsoundrandomization_time"}

static

Definition at line 255 of file snd_main.c.

{CF_CLIENT, "snd_identicalsoundrandomization_tics", "0", "if nonzero, how many tics to limit sound randomization as defined by snd_identicalsoundrandomization_time"};

Referenced by S_Init(), and S_StartSound_StartPosition_Flags().

snd_identicalsoundrandomization_time

cvar_t snd_identicalsoundrandomization_time = {CF_CLIENT, "snd_identicalsoundrandomization_time", "0.1", "how much seconds to randomly skip (positive) or delay (negative) sounds when multiple identical sounds are started on the same frame"}

static

Definition at line 254 of file snd_main.c.

{CF_CLIENT, "snd_identicalsoundrandomization_time", "0.1", "how much seconds to randomly skip (positive) or delay (negative) sounds when multiple identical sounds are started on the same frame"};

Referenced by S_Init(), and S_StartSound_StartPosition_Flags().

snd_initialized

cvar_t snd_initialized = {CF_CLIENT | CF_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"}

Definition at line 167 of file snd_main.c.

{CF_CLIENT | CF_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"};

Referenced by CL_ParseServerMessage(), M_Options_Draw(), S_FindName(), S_Init(), S_LocalSoundEx(), S_PrecacheSound(), S_SoundLength(), S_Startup(), S_Terminate(), and VM_precache_sound().

snd_maxchannelvolume

cvar_t snd_maxchannelvolume = {CF_CLIENT | CF_ARCHIVE, "snd_maxchannelvolume", "10", "maximum volume of a single sound"}

Definition at line 192 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_maxchannelvolume", "10", "maximum volume of a single sound"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_mempool

mempool_t* snd_mempool

Definition at line 144 of file snd_main.c.

Referenced by OGG_GetSamplesFloat(), OGG_LoadVorbisFile(), S_FindName(), S_Init(), S_LoadWavFile(), S_Terminate(), S_Update(), Snd_CreateRingBuffer(), XMP_GetSamplesFloat(), and XMP_LoadModFile().

snd_mutewhenidle

cvar_t snd_mutewhenidle = {CF_CLIENT | CF_ARCHIVE, "snd_mutewhenidle", "1", "1 disables sound output when game window is inactive, 2 disables it only when the window is minimised"}

Definition at line 193 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_mutewhenidle", "1", "1 disables sound output when game window is inactive, 2 disables it only when the window is minimised"};

Referenced by S_Init(), and S_Update().

snd_playerchannel0volume

cvar_t snd_playerchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of player entities (DEPRECATED)"}

Definition at line 204 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel1volume

cvar_t snd_playerchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel1volume", "1", "volume multiplier of the 1st entity channel of player entities (DEPRECATED)"}

Definition at line 205 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel1volume", "1", "volume multiplier of the 1st entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel2volume

cvar_t snd_playerchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel2volume", "1", "volume multiplier of the 2nd entity channel of player entities (DEPRECATED)"}

Definition at line 206 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel2volume", "1", "volume multiplier of the 2nd entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel3volume

cvar_t snd_playerchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel3volume", "1", "volume multiplier of the 3rd entity channel of player entities (DEPRECATED)"}

Definition at line 207 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel3volume", "1", "volume multiplier of the 3rd entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel4volume

cvar_t snd_playerchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel4volume", "1", "volume multiplier of the 4th entity channel of player entities (DEPRECATED)"}

Definition at line 208 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel4volume", "1", "volume multiplier of the 4th entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel5volume

cvar_t snd_playerchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel5volume", "1", "volume multiplier of the 5th entity channel of player entities (DEPRECATED)"}

Definition at line 209 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel5volume", "1", "volume multiplier of the 5th entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel6volume

cvar_t snd_playerchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel6volume", "1", "volume multiplier of the 6th entity channel of player entities (DEPRECATED)"}

Definition at line 210 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel6volume", "1", "volume multiplier of the 6th entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_playerchannel7volume

cvar_t snd_playerchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel7volume", "1", "volume multiplier of the 7th entity channel of player entities (DEPRECATED)"}

Definition at line 211 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_playerchannel7volume", "1", "volume multiplier of the 7th entity channel of player entities (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_precache

cvar_t snd_precache = {CF_CLIENT, "snd_precache", "1", "loads sounds before they are used"}

static

Definition at line 238 of file snd_main.c.

{CF_CLIENT, "snd_precache", "1", "loads sounds before they are used"};

Referenced by S_Init(), and S_PrecacheSound().

snd_renderbuffer

snd_ringbuffer_t* snd_renderbuffer = NULL

Definition at line 131 of file snd_main.c.

Referenced by Buffer_Callback(), S_GetSoundChannels(), S_GetSoundRate(), S_GetSoundWidth(), S_LoadSound(), S_MixToBuffer(), S_PaintAndSubmit(), S_SetChannelLayout(), S_Shutdown(), S_SoftClipPaintBuffer(), S_SoundInfo_f(), S_StartSound_StartPosition_Flags(), S_Startup(), S_StaticSound(), S_StopAllSounds(), S_Update(), SndSys_Init(), and SndSys_Shutdown().

snd_show

cvar_t snd_show = {CF_CLIENT, "snd_show", "0", "shows some statistics about sound mixing"}

static

Definition at line 241 of file snd_main.c.

{CF_CLIENT, "snd_show", "0", "shows some statistics about sound mixing"};

Referenced by S_Init(), and S_Update().

snd_softclip

cvar_t snd_softclip = {CF_CLIENT | CF_ARCHIVE, "snd_softclip", "0", "Use soft-clipping. Soft-clipping can make the sound more smooth if very high volume levels are used. Enable this option if the dynamic range of the loudspeakers is very low. WARNING: This feature creates distortion and should be considered a last resort."}

Definition at line 194 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_softclip", "0", "Use soft-clipping. Soft-clipping can make the sound more smooth if very high volume levels are used. Enable this option if the dynamic range of the loudspeakers is very low. WARNING: This feature creates distortion and should be considered a last resort."};

Referenced by S_Init(), and S_SoftClipPaintBuffer().

snd_soundradius

cvar_t snd_soundradius = {CF_CLIENT | CF_ARCHIVE, "snd_soundradius", "1200", "radius of weapon sounds and other standard sound effects (monster idle noises are half this radius and flickering light noises are one third of this radius)"}

Definition at line 178 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_soundradius", "1200", "radius of weapon sounds and other standard sound effects (monster idle noises are half this radius and flickering light noises are one third of this radius)"};

Referenced by S_Init(), S_PlaySfxOnChannel(), and S_StartSound_StartPosition_Flags().

snd_spatialization_control

cvar_t snd_spatialization_control = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_control", "0", "enable spatialization control (headphone friendly mode)"}

Definition at line 186 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_control", "0", "enable spatialization control (headphone friendly mode)"};

Referenced by S_Init(), and S_Update().

snd_spatialization_max

cvar_t snd_spatialization_max = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max", "0.95", "maximum spatialization of sounds"}

Definition at line 184 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max", "0.95", "maximum spatialization of sounds"};

Referenced by S_Init(), and S_Update().

snd_spatialization_max_radius

cvar_t snd_spatialization_max_radius = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max_radius", "100", "use maximum spatialization below this radius"}

Definition at line 182 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max_radius", "100", "use maximum spatialization below this radius"};

Referenced by S_Init(), and S_Update().

snd_spatialization_min

cvar_t snd_spatialization_min = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min", "0.70", "minimum spatializazion of sounds"}

Definition at line 183 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min", "0.70", "minimum spatializazion of sounds"};

Referenced by S_Init(), and S_Update().

snd_spatialization_min_radius

cvar_t snd_spatialization_min_radius = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min_radius", "10000", "use minimum spatialization above to this radius"}

Definition at line 181 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min_radius", "10000", "use minimum spatialization above to this radius"};

Referenced by S_Init(), and S_Update().

snd_spatialization_occlusion

cvar_t snd_spatialization_occlusion = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_occlusion", "1", "enable occlusion testing on spatialized sounds, which simply quiets sounds that are blocked by the world; 1 enables PVS method, 2 enables LineOfSight method, 3 enables both"}

Definition at line 189 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_occlusion", "1", "enable occlusion testing on spatialized sounds, which simply quiets sounds that are blocked by the world; 1 enables PVS method, 2 enables LineOfSight method, 3 enables both"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_spatialization_power

cvar_t snd_spatialization_power = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_power", "0", "exponent of the spatialization falloff curve (0: logarithmic)"}

Definition at line 185 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_power", "0", "exponent of the spatialization falloff curve (0: logarithmic)"};

Referenced by S_Init(), and S_Update().

snd_spatialization_prologic

cvar_t snd_spatialization_prologic = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic", "0", "use dolby prologic (I, II or IIx) encoding (snd_channels must be 2)"}

Definition at line 187 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic", "0", "use dolby prologic (I, II or IIx) encoding (snd_channels must be 2)"};

Referenced by S_Init(), S_UpdateAmbientSounds(), and SND_Spatialize_WithSfx().

snd_spatialization_prologic_frontangle

cvar_t snd_spatialization_prologic_frontangle = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic_frontangle", "30", "the angle between the front speakers and the center speaker"}

Definition at line 188 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic_frontangle", "30", "the angle between the front speakers and the center speaker"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_speakerlayout

speakerlayout_t snd_speakerlayout

Definition at line 44 of file snd_main.c.

Referenced by S_MixToBuffer(), S_SetChannelLayout(), S_Update(), S_UpdateAmbientSounds(), and SND_Spatialize_WithSfx().

snd_speakerlayouts

const speakerlayout_t snd_speakerlayouts[]

static

Definition at line 50 of file snd_main.c.

{
    {
        "surround71", 8,
        {
            {0, 45, 0.2f, 0.2f, 0.5f}, // front left
            {1, 315, 0.2f, 0.2f, 0.5f}, // front right
            {2, 135, 0.2f, 0.2f, 0.5f}, // rear left
            {3, 225, 0.2f, 0.2f, 0.5f}, // rear right
            {4, 0, 0.2f, 0.2f, 0.5f}, // front center
            {5, 0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so...  no lfe)
            {6, 90, 0.2f, 0.2f, 0.5f}, // side left
            {7, 180, 0.2f, 0.2f, 0.5f}, // side right
        }
    },
    {
        "surround51", 6,
        {
            {0, 45, 0.2f, 0.2f, 0.5f}, // front left
            {1, 315, 0.2f, 0.2f, 0.5f}, // front right
            {2, 135, 0.2f, 0.2f, 0.5f}, // rear left
            {3, 225, 0.2f, 0.2f, 0.5f}, // rear right
            {4, 0, 0.2f, 0.2f, 0.5f}, // front center
            {5, 0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so...  no lfe)
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
        }
    },
    {
        // these systems sometimes have a subwoofer as well, but it has no
        // channel of its own
        "surround40", 4,
        {
            {0, 45, 0.3f, 0.3f, 0.8f}, // front left
            {1, 315, 0.3f, 0.3f, 0.8f}, // front right
            {2, 135, 0.3f, 0.3f, 0.8f}, // rear left
            {3, 225, 0.3f, 0.3f, 0.8f}, // rear right
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
        }
    },
    {
        // these systems sometimes have a subwoofer as well, but it has no
        // channel of its own
        "stereo", 2,
        {
            {0, 90, 0.5f, 0.5f, 1}, // side left
            {1, 270, 0.5f, 0.5f, 1}, // side right
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
        }
    },
    {
        "mono", 1,
        {
            {0, 0, 0, 1, 1}, // center
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0},
        }
    }
};

Referenced by S_SetChannelLayout().

snd_speed

cvar_t snd_speed = {CF_CLIENT | CF_ARCHIVE, "snd_speed", "48000", "sound output frequency, in hertz"}

static

Definition at line 245 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_speed", "48000", "sound output frequency, in hertz"};

Referenced by S_Init(), and S_Startup().

snd_startloopingsounds

cvar_t snd_startloopingsounds = {CF_CLIENT, "snd_startloopingsounds", "1", "whether to start sounds that would loop (you want this to be 1); existing sounds are not affected"}

static

Definition at line 250 of file snd_main.c.

{CF_CLIENT, "snd_startloopingsounds", "1", "whether to start sounds that would loop (you want this to be 1); existing sounds are not affected"};

Referenced by S_Init(), and S_PlaySfxOnChannel().

snd_startnonloopingsounds

cvar_t snd_startnonloopingsounds = {CF_CLIENT, "snd_startnonloopingsounds", "1", "whether to start sounds that would not loop (you want this to be 1); existing sounds are not affected"}

static

Definition at line 251 of file snd_main.c.

{CF_CLIENT, "snd_startnonloopingsounds", "1", "whether to start sounds that would not loop (you want this to be 1); existing sounds are not affected"};

Referenced by S_Init(), and S_PlaySfxOnChannel().

snd_starttime

double snd_starttime = 0.0

static

Definition at line 135 of file snd_main.c.

Referenced by S_PaintAndSubmit(), and S_Startup().

snd_staticvolume

cvar_t snd_staticvolume = {CF_CLIENT | CF_ARCHIVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"}

Definition at line 177 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_streaming

cvar_t snd_streaming = {CF_CLIENT | CF_ARCHIVE, "snd_streaming", "1", "enables keeping compressed ogg sound files compressed, decompressing them only as needed, otherwise they will be decompressed completely at load (may use a lot of memory); when set to 2, streaming is performed even if this would waste memory"}

Definition at line 171 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_streaming", "1", "enables keeping compressed ogg sound files compressed, decompressing them only as needed, otherwise they will be decompressed completely at load (may use a lot of memory); when set to 2, streaming is performed even if this would waste memory"};

Referenced by OGG_LoadVorbisFile(), and S_Init().

snd_streaming_length

cvar_t snd_streaming_length = {CF_CLIENT | CF_ARCHIVE, "snd_streaming_length", "1", "decompress sounds completely if they are less than this play time when snd_streaming is 1"}

Definition at line 172 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_streaming_length", "1", "decompress sounds completely if they are less than this play time when snd_streaming is 1"};

Referenced by OGG_LoadVorbisFile(), and S_Init().

snd_swapstereo

cvar_t snd_swapstereo = {CF_CLIENT | CF_ARCHIVE, "snd_swapstereo", "0", "swaps left/right speakers for old ISA soundblaster cards"}

Definition at line 191 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_swapstereo", "0", "swaps left/right speakers for old ISA soundblaster cards"};

Referenced by S_Init(), S_SetChannelLayout(), and S_Update().

snd_threaded

qbool snd_threaded = false

enables use of snd_usethreadedmixing, provided that no sound hacks are in effect (like timedemo)

Definition at line 136 of file snd_main.c.

Referenced by S_PaintAndSubmit(), and SndSys_Init().

snd_usethreadedmixing

qbool snd_usethreadedmixing = false

if true, the main thread does not mix sound, soundtime does not advance, and neither does snd_renderbuffer->endframe, instead the audio thread will call S_MixToBuffer as needed

Definition at line 137 of file snd_main.c.

Referenced by Buffer_Callback(), S_MixToBuffer(), and S_PaintAndSubmit().

snd_waterfx

cvar_t snd_waterfx = {CF_CLIENT | CF_ARCHIVE, "snd_waterfx", "1", "underwater sound filter strength"}

Definition at line 173 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_waterfx", "1", "underwater sound filter strength"};

Referenced by S_Init(), and S_SetUnderwaterIntensity().

snd_width

cvar_t snd_width = {CF_CLIENT | CF_ARCHIVE, "snd_width", "4", "sound output precision, in bytes - 1 = 8bit, 2 = 16bit, 4 = 32bit float"}

static

Definition at line 246 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_width", "4", "sound output precision, in bytes - 1 = 8bit, 2 = 16bit, 4 = 32bit float"};

Referenced by S_Init(), and S_Startup().

snd_worldchannel0volume

cvar_t snd_worldchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of the world entity (DEPRECATED)"}

Definition at line 212 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel1volume

cvar_t snd_worldchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel1volume", "1", "volume multiplier of the 1st entity channel of the world entity (DEPRECATED)"}

Definition at line 213 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel1volume", "1", "volume multiplier of the 1st entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel2volume

cvar_t snd_worldchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel2volume", "1", "volume multiplier of the 2nd entity channel of the world entity (DEPRECATED)"}

Definition at line 214 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel2volume", "1", "volume multiplier of the 2nd entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel3volume

cvar_t snd_worldchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel3volume", "1", "volume multiplier of the 3rd entity channel of the world entity (DEPRECATED)"}

Definition at line 215 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel3volume", "1", "volume multiplier of the 3rd entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel4volume

cvar_t snd_worldchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel4volume", "1", "volume multiplier of the 4th entity channel of the world entity (DEPRECATED)"}

Definition at line 216 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel4volume", "1", "volume multiplier of the 4th entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel5volume

cvar_t snd_worldchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel5volume", "1", "volume multiplier of the 5th entity channel of the world entity (DEPRECATED)"}

Definition at line 217 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel5volume", "1", "volume multiplier of the 5th entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel6volume

cvar_t snd_worldchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel6volume", "1", "volume multiplier of the 6th entity channel of the world entity (DEPRECATED)"}

Definition at line 218 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel6volume", "1", "volume multiplier of the 6th entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

snd_worldchannel7volume

cvar_t snd_worldchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel7volume", "1", "volume multiplier of the 7th entity channel of the world entity (DEPRECATED)"}

Definition at line 219 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "snd_worldchannel7volume", "1", "volume multiplier of the 7th entity channel of the world entity (DEPRECATED)"};

Referenced by S_Init(), and SND_Spatialize_WithSfx().

soundtime

unsigned int soundtime = 0

static

Definition at line 132 of file snd_main.c.

Referenced by S_PaintAndSubmit(), and S_Startup().

spatialdiff

float spatialdiff

static

Definition at line 160 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

spatialfactor

float spatialfactor

static

Definition at line 160 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

spatialmethod

spatialmethod_t spatialmethod

Definition at line 162 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

spatialmin

float spatialmin

static

Definition at line 160 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

spatialoffset

float spatialoffset

static

Definition at line 160 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

spatialpower

float spatialpower

static

Definition at line 160 of file snd_main.c.

Referenced by S_Update(), and SND_Spatialize_WithSfx().

total_channels

unsigned int total_channels

Definition at line 129 of file snd_main.c.

Referenced by S_FreeSfx(), S_GetEntChannelPosition(), S_Init(), S_MixToBuffer(), S_PauseGameSounds(), S_SetChannelFlag(), S_SoundInfo_f(), S_StaticSound(), S_StopAllSounds(), S_StopChannel(), and S_Update().

v_flipped

cvar_t v_flipped

extern

Definition at line 20 of file gl_backend.c.

{CF_CLIENT, "v_flipped", "0", "mirror the screen (poor man's left handed mode)"};

Referenced by gl_backend_init(), R_SetViewport(), R_Viewport_InitOrtho3D(), R_Viewport_InitPerspective(), R_Viewport_InitPerspectiveInfinite(), S_SetChannelLayout(), and S_Update().

volume

cvar_t volume = {CF_CLIENT | CF_ARCHIVE, "volume", "0.7", "volume of sound effects"}

Definition at line 166 of file snd_main.c.

{CF_CLIENT | CF_ARCHIVE, "volume", "0.7", "volume of sound effects"};

Referenced by M_Menu_Options_AdjustSliders(), M_Options_Draw(), S_Init(), S_UpdateAmbientSounds(), and SND_Spatialize_WithSfx().