sound.h File Reference

#include "matrixlib.h"

Include dependency graph for sound.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	CHAN_ENGINE2CVAR(c)
#define	CHAN_ENGINE2NET(c)
#define	CHAN_ENGINE2USER(c)
#define	CHAN_MAX_AUTO   0
#define	CHAN_MAX_SINGLE   127
#define	CHAN_MIN_AUTO   -128
#define	CHAN_MIN_SINGLE   1
#define	CHAN_NET2ENGINE(c)
#define	CHAN_USER2ENGINE(c)
#define	CHANNELFLAG_FORCELOOP   (1 << 1)
#define	CHANNELFLAG_FULLVOLUME   (1 << 4)
#define	CHANNELFLAG_LOCALSOUND   (1 << 2)
#define	CHANNELFLAG_NONE   0
#define	CHANNELFLAG_PAUSED   (1 << 3)
#define	CHANNELFLAG_RELIABLE   (1 << 0)
#define	DEFAULT_SOUND_PACKET_ATTENUATION   1.0
#define	DEFAULT_SOUND_PACKET_VOLUME   255
#define	IS_CHAN(n)
#define	IS_CHAN_AUTO(n)
#define	IS_CHAN_SINGLE(n)

Functions
void	S_BlockSound (void)
void	S_ClearUsed (void)
sfx_t *	S_FindName (const char *name)
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 *s)
qbool	S_LocalSoundEx (const char *s, int chan, float fvol)
void	S_PauseGameSounds (qbool toggle)
sfx_t *	S_PrecacheSound (const char *sample, qbool complain, qbool levelsound)
void	S_PurgeUnused (void)
qbool	S_SetChannelFlag (unsigned int ch_ind, unsigned int flag, qbool value)
void	S_SetChannelSpeed (unsigned int ch_ind, float fspeed)
void	S_SetChannelVolume (unsigned int ch_ind, float fvol)
void	S_Shutdown (void)
float	S_SoundLength (const char *name)
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 (struct cmd_state_s *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_UnblockSound (void)
void	S_UnloadAllSounds_f (struct cmd_state_s *cmd)
void	S_Update (const matrix4x4_t *listenermatrix)

Variables
cvar_t	bgmvolume
cvar_t	snd_initialized
cvar_t	volume

Macro Definition Documentation

CHAN_ENGINE2CVAR

#define CHAN_ENGINE2CVAR

(

c

)

Value:

(abs(c))

Definition at line 92 of file sound.h.

Referenced by SND_Spatialize_WithSfx().

CHAN_ENGINE2NET

#define CHAN_ENGINE2NET

(

c

)

Value:

(c)

Definition at line 85 of file sound.h.

Referenced by SV_StartSound().

CHAN_ENGINE2USER

#define CHAN_ENGINE2USER

(

c

)

Value:

(c)

Definition at line 91 of file sound.h.

Referenced by CL_VM_Event_Sound().

CHAN_MAX_AUTO

#define CHAN_MAX_AUTO   0

Definition at line 77 of file sound.h.

CHAN_MAX_SINGLE

#define CHAN_MAX_SINGLE   127

Definition at line 79 of file sound.h.

CHAN_MIN_AUTO

#define CHAN_MIN_AUTO   -128

Definition at line 76 of file sound.h.

CHAN_MIN_SINGLE

#define CHAN_MIN_SINGLE   1

Definition at line 78 of file sound.h.

CHAN_NET2ENGINE

#define CHAN_NET2ENGINE

(

c

)

Value:

(c)

Definition at line 86 of file sound.h.

CHAN_USER2ENGINE

#define CHAN_USER2ENGINE

(

c

)

Value:

(c)

Definition at line 90 of file sound.h.

Referenced by VM_getsoundtime(), and VM_SV_sound().

CHANNELFLAG_FORCELOOP

#define CHANNELFLAG_FORCELOOP   (1 << 1)

Definition at line 39 of file sound.h.

Referenced by CDAudio_Play_byName(), S_ClearUsed(), S_MixToBuffer(), S_PlaySfxOnChannel(), S_SetChannelFlag(), S_StaticSound(), SND_PickChannel(), VM_CL_sound(), and VM_SV_sound().

CHANNELFLAG_FULLVOLUME

#define CHANNELFLAG_FULLVOLUME   (1 << 4)

Definition at line 42 of file sound.h.

Referenced by CDAudio_Play_byName(), S_SetChannelFlag(), SND_Spatialize_WithSfx(), VM_CL_sound(), and VM_SV_sound().

CHANNELFLAG_LOCALSOUND

#define CHANNELFLAG_LOCALSOUND   (1 << 2)

Definition at line 40 of file sound.h.

Referenced by CDAudio_Play_byName(), S_LocalSoundEx(), S_PauseGameSounds(), S_Play_Common(), and S_SetChannelFlag().

CHANNELFLAG_NONE

#define CHANNELFLAG_NONE   0

Definition at line 37 of file sound.h.

Referenced by CL_ParseStartSoundPacket(), and S_StartSound().

CHANNELFLAG_PAUSED

#define CHANNELFLAG_PAUSED   (1 << 3)

Definition at line 41 of file sound.h.

Referenced by CDAudio_Pause(), CDAudio_Resume(), S_MixToBuffer(), S_PauseGameSounds(), S_SetChannelFlag(), VM_CL_sound(), and VM_SV_sound().

CHANNELFLAG_RELIABLE

#define CHANNELFLAG_RELIABLE   (1 << 0)

Definition at line 38 of file sound.h.

Referenced by VM_CL_sound(), and VM_SV_sound().

DEFAULT_SOUND_PACKET_ATTENUATION

#define DEFAULT_SOUND_PACKET_ATTENUATION   1.0

Definition at line 33 of file sound.h.

Referenced by CL_ParseStartSoundPacket(), SV_StartPointSound(), and SV_StartSound().

DEFAULT_SOUND_PACKET_VOLUME

#define DEFAULT_SOUND_PACKET_VOLUME   255

Definition at line 32 of file sound.h.

Referenced by CL_ParseStartSoundPacket(), SV_StartPointSound(), and SV_StartSound().

IS_CHAN

#define IS_CHAN

(

n

)

Value:

(IS_CHAN_AUTO(n) || IS_CHAN_SINGLE(n))

Definition at line 82 of file sound.h.

Referenced by SV_StartSound(), VM_CL_sound(), VM_getsoundtime(), and VM_SV_sound().

IS_CHAN_AUTO

#define IS_CHAN_AUTO

(

n

)

Value:

((n) >= CHAN_MIN_AUTO && (n) <= CHAN_MAX_AUTO)

Definition at line 80 of file sound.h.

IS_CHAN_SINGLE

#define IS_CHAN_SINGLE

(

n

)

Value:

((n) >= CHAN_MIN_SINGLE && (n) <= CHAN_MAX_SINGLE)

Definition at line 81 of file sound.h.

Referenced by S_StartSound_StartPosition_Flags(), and SND_PickChannel().

Function Documentation

S_BlockSound()

void S_BlockSound

(

void

)

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_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 *

s

)

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 *	s,
		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_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_PrecacheSound()

sfx_t * S_PrecacheSound	(	const char *	sample,
		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_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_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_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_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

(

struct cmd_state_s *

cmd

)

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_UnblockSound()

void S_UnblockSound

(

void

)

S_UnloadAllSounds_f()

void S_UnloadAllSounds_f

(

struct cmd_state_s *

cmd

)

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().

Variable Documentation

bgmvolume

cvar_t bgmvolume

extern

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().

snd_initialized

cvar_t snd_initialized

extern

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().

volume

cvar_t volume

extern

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().