snd_main.h File Reference

#include <stddef.h>
#include "qtypes.h"
#include "qdefs.h"

Include dependency graph for snd_main.h:

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

Go to the source code of this file.

Data Structures
struct	channel_t
struct	listener_t
struct	portable_sampleframe_t
	exported for capturevideo so ogg can see all channels More...
struct	sfx_t
struct	snd_buffer_t
struct	snd_fetcher_t
struct	snd_format_t
struct	snd_ringbuffer_t
struct	speakerlayout_t

Macros
#define	SFXFLAG_FILEMISSING   (1 << 0)
	wasn't able to load the associated sound file
#define	SFXFLAG_LEVELSOUND   (1 << 1)
	the sfx is part of the server or client precache list for this level
#define	SFXFLAG_MENUSOUND   (1 << 3)
	not freed during level change (menu sounds, music, etc)
#define	SFXFLAG_NONE   0
#define	SFXFLAG_STREAMED   (1 << 2)
	informative only. You shouldn't need to know that
#define	SND_CHANNELLAYOUT_ALSA   2
#define	SND_CHANNELLAYOUT_AUTO   0
#define	SND_CHANNELLAYOUT_STANDARD   1
#define	SND_LISTENERS   8
#define	STREAM_BUFFERSIZE   16384
	in sampleframes

Typedefs
typedef void(*	snd_fetcher_freesfx_t) (struct sfx_s *sfx)
typedef void(*	snd_fetcher_getsamplesfloat_t) (channel_t *ch, struct sfx_s *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat)
typedef void(*	snd_fetcher_stopchannel_t) (channel_t *ch)

Functions
qbool	S_LoadSound (struct sfx_s *sfx, qbool complain)
void	S_MixToBuffer (void *stream, unsigned int frames)
void	S_SetUnderwaterIntensity (void)
snd_ringbuffer_t *	Snd_CreateRingBuffer (const snd_format_t *format, unsigned int sampleframes, void *buffer)
	If "buffer" is NULL, the function allocates one buffer of "sampleframes" sample frames itself (if "sampleframes" is 0, the function chooses the size).
unsigned int	SndSys_GetSoundTime (void)
	Returns the number of sample frames consumed since the sound started.
qbool	SndSys_Init (snd_format_t *fmt)
	Create "snd_renderbuffer", attempting to use the chosen sound format, but accepting if the driver wants to change it (e.g.
qbool	SndSys_LockRenderBuffer (void)
	Get the exclusive lock on "snd_renderbuffer".
void	SndSys_SendKeyEvents (void)
	if the sound system can generate events, send them
void	SndSys_Shutdown (void)
	Stop the sound card, delete "snd_renderbuffer" and free its other resources.
void	SndSys_Submit (void)
	Submit the contents of "snd_renderbuffer" to the sound card.
void	SndSys_UnlockRenderBuffer (void)
	Release the exclusive lock on "snd_renderbuffer".

Variables
channel_t	channels [MAX_CHANNELS]
qbool	simsound
	If simsound is true, the sound card is not initialized and no sound is submitted to it.
bool	snd_blocked
	When true, we submit silence to the audio device.
cvar_t	snd_bufferlength
cvar_t	snd_channellayout
struct mempool_s *	snd_mempool
snd_ringbuffer_t *	snd_renderbuffer
cvar_t	snd_streaming
cvar_t	snd_streaming_length
qbool	snd_threaded
	enables use of snd_usethreadedmixing, provided that no sound hacks are in effect (like timedemo)
qbool	snd_usethreadedmixing
	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
unsigned int	total_channels

Macro Definition Documentation

SFXFLAG_FILEMISSING

#define SFXFLAG_FILEMISSING   (1 << 0)

wasn't able to load the associated sound file

Definition at line 60 of file snd_main.h.

Referenced by S_LoadSound().

SFXFLAG_LEVELSOUND

#define SFXFLAG_LEVELSOUND   (1 << 1)

the sfx is part of the server or client precache list for this level

Definition at line 61 of file snd_main.h.

Referenced by S_ClearUsed(), S_FreeSfx(), S_PrecacheSound(), and S_PurgeUnused().

SFXFLAG_MENUSOUND

#define SFXFLAG_MENUSOUND   (1 << 3)

not freed during level change (menu sounds, music, etc)

Definition at line 63 of file snd_main.h.

Referenced by S_ClearUsed(), S_FreeSfx(), S_LocalSoundEx(), S_PrecacheSound(), S_PurgeUnused(), and S_SoundList_f().

SFXFLAG_NONE

#define SFXFLAG_NONE   0

Definition at line 59 of file snd_main.h.

SFXFLAG_STREAMED

#define SFXFLAG_STREAMED   (1 << 2)

informative only. You shouldn't need to know that

Definition at line 62 of file snd_main.h.

Referenced by OGG_LoadVorbisFile(), S_LoadWavFile(), S_SoundList_f(), and XMP_LoadModFile().

SND_CHANNELLAYOUT_ALSA

#define SND_CHANNELLAYOUT_ALSA   2

Definition at line 136 of file snd_main.h.

Referenced by S_SetChannelLayout().

SND_CHANNELLAYOUT_AUTO

#define SND_CHANNELLAYOUT_AUTO   0

Definition at line 134 of file snd_main.h.

Referenced by S_SetChannelLayout(), S_Startup(), and SndSys_Init().

SND_CHANNELLAYOUT_STANDARD

#define SND_CHANNELLAYOUT_STANDARD   1

Definition at line 135 of file snd_main.h.

Referenced by S_SetChannelLayout(), and SndSys_Init().

SND_LISTENERS

#define SND_LISTENERS   8

Definition at line 84 of file snd_main.h.

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

STREAM_BUFFERSIZE

#define STREAM_BUFFERSIZE   16384

in sampleframes

Definition at line 150 of file snd_main.h.

Typedef Documentation

snd_fetcher_freesfx_t

typedef void(* snd_fetcher_freesfx_t) (struct sfx_s *sfx)

Definition at line 115 of file snd_main.h.

snd_fetcher_getsamplesfloat_t

typedef void(* snd_fetcher_getsamplesfloat_t) (channel_t *ch, struct sfx_s *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat)

Definition at line 113 of file snd_main.h.

snd_fetcher_stopchannel_t

typedef void(* snd_fetcher_stopchannel_t) (channel_t *ch)

Definition at line 114 of file snd_main.h.

Function Documentation

S_LoadSound()

qbool S_LoadSound	(	struct sfx_s *	sfx,
		qbool	complain )

References buffer, and format.

Referenced by S_MixToBuffer(), and S_PrecacheSound().

S_MixToBuffer()

void S_MixToBuffer	(	void *	stream,
		unsigned int	frames )

Definition at line 369 of file snd_mix.c.

{
    int channelindex;
    channel_t *ch;
    int totalmixframes;
    unsigned char *outbytes = (unsigned char *) stream;
    sfx_t *sfx;
    portable_sampleframe_t *paint;
    int wantframes;
    int i;
    int count;
    int fetched;
    int fetch;
    int istartframe;
    int iendframe;
    int ilengthframes;
    int totallength;
    int loopstart;
    int indexfrac;
    int indexfracstep;
#define S_FETCHBUFFERSIZE 4096
    float fetchsampleframes[S_FETCHBUFFERSIZE*2];
    const float *fetchsampleframe;
    float vol[SND_LISTENERS];
    float lerp[2];
    float sample[3];
    double posd;
    double speedd;
    float maxvol;
    qbool looping;
    qbool silent;
 
    // mix as many times as needed to fill the requested buffer
    while (bufferframes)
    {
        // limit to the size of the paint buffer
        totalmixframes = min(bufferframes, PAINTBUFFER_SIZE);
 
        // clear the paint buffer
        memset(paintbuffer, 0, totalmixframes * sizeof(paintbuffer[0]));
 
        // paint in the channels.
        // channels with zero volumes still advance in time but don't paint.
        ch = channels; // cppcheck complains here but it is wrong, channels is a channel_t[MAX_CHANNELS] and not an int
        for (channelindex = 0;channelindex < (int)total_channels;channelindex++, ch++)
        {
            sfx = ch->sfx;
            if (sfx == NULL)
                continue;
            if (!S_LoadSound (sfx, true))
                continue;
            if (ch->flags & CHANNELFLAG_PAUSED)
                continue;
            if (!sfx->total_length)
                continue;
 
            // copy the channel information to the stack for reference, otherwise the
            // values might change during a mix if the spatializer is updating them
            // (note: this still may get some old and some new values!)
            posd = ch->position;
            speedd = ch->mixspeed * sfx->format.speed / snd_renderbuffer->format.speed;
            for (i = 0;i < SND_LISTENERS;i++)
                vol[i] = ch->volume[i];
 
            // check total volume level, because we can skip some code on silent sounds but other code must still run (position updates mainly)
            maxvol = 0;
            for (i = 0;i < SND_LISTENERS;i++)
                if(vol[i] > maxvol)
                    maxvol = vol[i];
            switch(snd_renderbuffer->format.width)
            {
                case 1: // 8bpp
                    silent = maxvol < (1.0f / (256.0f));
                    // so silent it has zero effect
                    break;
                case 2: // 16bpp
                    silent = maxvol < (1.0f / (65536.0f));
                    // so silent it has zero effect
                    break;
                default: // floating point
                    silent = maxvol < 1.0e-13f;
                    // 130 dB is difference between hearing
                    // threshold and a jackhammer from
                    // working distance.
                    // therefore, anyone who turns up
                    // volume so much they notice this
                    // cutoff, likely already has their
                    // ear-drums blown out anyway.
                    break;
            }
 
            // when doing prologic mixing, some channels invert one side
            if (ch->prologic_invert == -1)
                vol[1] *= -1.0f;
 
            // get some sfx info in a consistent form
            totallength = sfx->total_length;
            loopstart = (int)sfx->loopstart < totallength ? (int)sfx->loopstart : ((ch->flags & CHANNELFLAG_FORCELOOP) ? 0 : totallength);
            looping = loopstart < totallength;
 
            // do the actual paint now (may skip work if silent)
            paint = paintbuffer;
            istartframe = 0;
            for (wantframes = totalmixframes;wantframes > 0;posd += count * speedd, wantframes -= count)
            {
                // check if this is a delayed sound
                if (posd < 0)
                {
                    // for a delayed sound we have to eat into the delay first
                    count = (int)floor(-posd / speedd) + 1;
                    count = bound(1, count, wantframes);
                    // let the for loop iterator apply the skip
                    continue;
                }
 
                // compute a fetch size that won't overflow our buffer
                count = wantframes;
                for (;;)
                {
                    istartframe = (int)floor(posd);
                    iendframe = (int)floor(posd + (count-1) * speedd);
                    ilengthframes = count > 1 ? (iendframe - istartframe + 2) : 2;
                    if (ilengthframes <= S_FETCHBUFFERSIZE)
                        break;
                    // reduce count by 25% and try again
                    count -= count >> 2;
                }
 
                // zero whole fetch buffer for safety
                // (floating point noise from uninitialized memory = HORRIBLE)
                // otherwise we would only need to clear the excess
                if (!silent)
                    memset(fetchsampleframes, 0, ilengthframes*sfx->format.channels*sizeof(fetchsampleframes[0]));
 
                // if looping, do multiple fetches
                fetched = 0;
                for (;;)
                {
                    fetch = min(ilengthframes - fetched, totallength - istartframe);
                    if (fetch > 0)
                    {
                        if (!silent)
                            sfx->fetcher->getsamplesfloat(ch, sfx, istartframe, fetch, fetchsampleframes + fetched*sfx->format.channels);
                        istartframe += fetch;
                        fetched += fetch;
                    }
                    if (istartframe == totallength && looping && fetched < ilengthframes)
                    {
                        // loop and fetch some more
                        posd += loopstart - totallength;
                        istartframe = loopstart;
                    }
                    else
                    {
                        break;
                    }
                }
 
                // set up our fixedpoint resampling variables (float to int conversions are expensive so do not do one per sampleframe)
                fetchsampleframe = fetchsampleframes;
                indexfrac = (int)floor((posd - floor(posd)) * 65536.0);
                indexfracstep = (int)floor(speedd * 65536.0);
                if (!silent)
                {
                    if (sfx->format.channels == 2)
                    {
                        // music is stereo
#if SND_LISTENERS != 8
#error the following code only supports up to 8 channels, update it
#endif
                        if (snd_speakerlayout.channels > 2)
                        {
                            // surround mixing
                            for (i = 0;i < count;i++, paint++)
                            {
                                lerp[1] = indexfrac * (1.0f / 65536.0f);
                                lerp[0] = 1.0f - lerp[1];
                                sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[2] * lerp[1];
                                sample[1] = fetchsampleframe[1] * lerp[0] + fetchsampleframe[3] * lerp[1];
                                sample[2] = (sample[0] + sample[1]) * 0.5f;
                                paint->sample[0] += sample[0] * vol[0];
                                paint->sample[1] += sample[1] * vol[1];
                                paint->sample[2] += sample[0] * vol[2];
                                paint->sample[3] += sample[1] * vol[3];
                                paint->sample[4] += sample[2] * vol[4];
                                paint->sample[5] += sample[2] * vol[5];
                                paint->sample[6] += sample[0] * vol[6];
                                paint->sample[7] += sample[1] * vol[7];
                                indexfrac += indexfracstep;
                                fetchsampleframe += 2 * (indexfrac >> 16);
                                indexfrac &= 0xFFFF;
                            }
                        }
                        else
                        {
                            // stereo mixing
                            for (i = 0;i < count;i++, paint++)
                            {
                                lerp[1] = indexfrac * (1.0f / 65536.0f);
                                lerp[0] = 1.0f - lerp[1];
                                sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[2] * lerp[1];
                                sample[1] = fetchsampleframe[1] * lerp[0] + fetchsampleframe[3] * lerp[1];
                                paint->sample[0] += sample[0] * vol[0];
                                paint->sample[1] += sample[1] * vol[1];
                                indexfrac += indexfracstep;
                                fetchsampleframe += 2 * (indexfrac >> 16);
                                indexfrac &= 0xFFFF;
                            }
                        }
                    }
                    else if (sfx->format.channels == 1)
                    {
                        // most sounds are mono
#if SND_LISTENERS != 8
#error the following code only supports up to 8 channels, update it
#endif
                        if (snd_speakerlayout.channels > 2)
                        {
                            // surround mixing
                            for (i = 0;i < count;i++, paint++)
                            {
                                lerp[1] = indexfrac * (1.0f / 65536.0f);
                                lerp[0] = 1.0f - lerp[1];
                                sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[1] * lerp[1];
                                paint->sample[0] += sample[0] * vol[0];
                                paint->sample[1] += sample[0] * vol[1];
                                paint->sample[2] += sample[0] * vol[2];
                                paint->sample[3] += sample[0] * vol[3];
                                paint->sample[4] += sample[0] * vol[4];
                                paint->sample[5] += sample[0] * vol[5];
                                paint->sample[6] += sample[0] * vol[6];
                                paint->sample[7] += sample[0] * vol[7];
                                indexfrac += indexfracstep;
                                fetchsampleframe += (indexfrac >> 16);
                                indexfrac &= 0xFFFF;
                            }
                        }
                        else
                        {
                            // stereo mixing
                            for (i = 0;i < count;i++, paint++)
                            {
                                lerp[1] = indexfrac * (1.0f / 65536.0f);
                                lerp[0] = 1.0f - lerp[1];
                                sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[1] * lerp[1];
                                paint->sample[0] += sample[0] * vol[0];
                                paint->sample[1] += sample[0] * vol[1];
                                indexfrac += indexfracstep;
                                fetchsampleframe += (indexfrac >> 16);
                                indexfrac &= 0xFFFF;
                            }
                        }
                    }
                }
            }
            ch->position = posd;
            if (!looping && istartframe == totallength)
                S_StopChannel(ch - channels, false, false);
        }
 
        S_SoftClipPaintBuffer(paintbuffer, totalmixframes, snd_renderbuffer->format.width, snd_renderbuffer->format.channels);
 
        S_UnderwaterFilter(totalmixframes);
 
 
#ifdef CONFIG_VIDEO_CAPTURE
        if (!snd_usethreadedmixing)
            S_CaptureAVISound(paintbuffer, totalmixframes);
#endif
 
        S_ConvertPaintBuffer(paintbuffer, outbytes, totalmixframes, snd_renderbuffer->format.width, snd_renderbuffer->format.channels);
 
        // advance the output pointer
        outbytes += totalmixframes * snd_renderbuffer->format.width * snd_renderbuffer->format.channels;
        bufferframes -= totalmixframes;
    }
}

References bound, CHANNELFLAG_FORCELOOP, CHANNELFLAG_PAUSED, channels, count, channel_t::flags, floor(), int(), min, channel_t::mixspeed, NULL, paintbuffer, PAINTBUFFER_SIZE, channel_t::position, channel_t::prologic_invert, S_ConvertPaintBuffer(), S_FETCHBUFFERSIZE, S_LoadSound(), S_SoftClipPaintBuffer(), S_StopChannel(), S_UnderwaterFilter(), portable_sampleframe_t::sample, channel_t::sfx, SND_LISTENERS, snd_renderbuffer, snd_speakerlayout, snd_usethreadedmixing, total_channels, and channel_t::volume.

Referenced by Buffer_Callback(), and S_PaintAndSubmit().

S_SetUnderwaterIntensity()

void S_SetUnderwaterIntensity

(

void

)

Definition at line 320 of file snd_mix.c.

{
    float target = cl.view_underwater ? bound(0.f, snd_waterfx.value, 2.f) : 0.f;
 
    if (underwater.intensity < target)
    {
        underwater.intensity += cl.realframetime * 4.f;
        underwater.intensity = min(underwater.intensity, target);
    }
    else if (underwater.intensity > target)
    {
        underwater.intensity -= cl.realframetime * 4.f;
        underwater.intensity = max(underwater.intensity, target);
    }
 
    underwater.alpha = underwater.intensity ? exp(-underwater.intensity * log(12.f)) : 1.f;
}

References bound, cl, log(), max, min, snd_waterfx, target, and underwater.

Referenced by S_UpdateAmbientSounds().

Snd_CreateRingBuffer()

snd_ringbuffer_t * Snd_CreateRingBuffer	(	const snd_format_t *	format,
		unsigned int	sampleframes,
		void *	buffer )

If "buffer" is NULL, the function allocates one buffer of "sampleframes" sample frames itself (if "sampleframes" is 0, the function chooses the size).

Definition at line 43 of file snd_mem.c.

{
    snd_ringbuffer_t *ringbuffer;
 
    // If the caller provides a buffer, it must give us its size
    if (sampleframes == 0 && buffer != NULL)
        return NULL;
 
    ringbuffer = (snd_ringbuffer_t*)Mem_Alloc(snd_mempool, sizeof (*ringbuffer));
    memset(ringbuffer, 0, sizeof(*ringbuffer));
    memcpy(&ringbuffer->format, format, sizeof(ringbuffer->format));
 
    // If we haven't been given a buffer
    if (buffer == NULL)
    {
        unsigned int maxframes;
        size_t memsize;
 
        if (sampleframes == 0)
            maxframes = (format->speed + 1) / 2;  // Make the sound buffer large enough for containing 0.5 sec of sound
        else
            maxframes = sampleframes;
 
        memsize = maxframes * format->width * format->channels;
        ringbuffer->ring = (unsigned char *) Mem_Alloc(snd_mempool, memsize);
        ringbuffer->maxframes = maxframes;
    }
    else
    {
        ringbuffer->ring = (unsigned char *) buffer;
        ringbuffer->maxframes = sampleframes;
    }
 
    return ringbuffer;
}

References buffer, format, snd_ringbuffer_t::format, snd_ringbuffer_t::maxframes, Mem_Alloc, NULL, snd_ringbuffer_t::ring, and snd_mempool.

Referenced by S_Startup(), and SndSys_Init().

SndSys_GetSoundTime()

unsigned int SndSys_GetSoundTime

(

void

)

Returns the number of sample frames consumed since the sound started.

Definition at line 209 of file snd_sdl.c.

{
    return sdlaudiotime;
}

References sdlaudiotime.

Referenced by S_PaintAndSubmit().

SndSys_Init()

qbool SndSys_Init

(

snd_format_t *

fmt

)

Create "snd_renderbuffer", attempting to use the chosen sound format, but accepting if the driver wants to change it (e.g.

7.1 to stereo or lowering the speed) Note: SDL automatically converts all formats, so this only fails if there is no audio

Definition at line 103 of file snd_sdl.c.

{
    unsigned int buffersize;
    SDL_AudioSpec wantspec;
    SDL_AudioSpec obtainspec;
 
    snd_threaded = false;
 
    Con_DPrint ("SndSys_Init: using the SDL module\n");
 
    // Init the SDL Audio subsystem
    if( SDL_InitSubSystem( SDL_INIT_AUDIO ) ) {
        Con_Print( "Initializing the SDL Audio subsystem failed!\n" );
        return false;
    }
 
    // SDL2 wiki recommends this range
    buffersize = bound(512, ceil((double)fmt->speed * snd_bufferlength.value / 1000.0), 8192);
 
    // Init the SDL Audio subsystem
    memset(&wantspec, 0, sizeof(wantspec));
    wantspec.callback = Buffer_Callback;
    wantspec.userdata = NULL;
    wantspec.freq = fmt->speed;
    wantspec.format = fmt->width == 1 ? AUDIO_U8 : (fmt->width == 2 ? AUDIO_S16SYS : AUDIO_F32);
    wantspec.channels = fmt->channels;
    wantspec.samples = CeilPowerOf2(buffersize);  // needs to be a power of 2 on some platforms.
 
    Con_Printf("Wanted audio Specification:\n"
                "    Channels  : %i\n"
                "    Format    : 0x%X\n"
                "    Frequency : %i\n"
                "    Samples   : %i\n",
                wantspec.channels, wantspec.format, wantspec.freq, wantspec.samples);
 
    if ((audio_device = SDL_OpenAudioDevice(NULL, 0, &wantspec, &obtainspec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE)) == 0)
    {
        Con_Printf(CON_ERROR "Failed to open the audio device! (%s)\n", SDL_GetError() );
        return false;
    }
 
    Con_Printf("Obtained audio specification:\n"
                "    Channels  : %i\n"
                "    Format    : 0x%X\n"
                "    Frequency : %i\n"
                "    Samples   : %i\n",
                obtainspec.channels, obtainspec.format, obtainspec.freq, obtainspec.samples);
 
    fmt->speed = obtainspec.freq;
    fmt->channels = obtainspec.channels;
 
    snd_threaded = true;
 
    snd_renderbuffer = Snd_CreateRingBuffer(fmt, 0, NULL);
    if (snd_channellayout.integer == SND_CHANNELLAYOUT_AUTO)
        Cvar_SetValueQuick (&snd_channellayout, SND_CHANNELLAYOUT_STANDARD);
 
    sdlaudiotime = 0;
    SDL_PauseAudioDevice(audio_device, 0);
 
    return true;
}

References audio_device, bound, Buffer_Callback(), ceil(), CeilPowerOf2(), snd_format_t::channels, Con_DPrint(), CON_ERROR, Con_Print(), Con_Printf(), Cvar_SetValueQuick(), NULL, sdlaudiotime, snd_bufferlength, snd_channellayout, SND_CHANNELLAYOUT_AUTO, SND_CHANNELLAYOUT_STANDARD, Snd_CreateRingBuffer(), snd_renderbuffer, snd_threaded, snd_format_t::speed, and snd_format_t::width.

Referenced by S_Startup().

SndSys_LockRenderBuffer()

qbool SndSys_LockRenderBuffer

(

void

)

Get the exclusive lock on "snd_renderbuffer".

Definition at line 222 of file snd_sdl.c.

{
    SDL_LockAudioDevice(audio_device);
    return true;
}

References audio_device.

Referenced by S_PaintAndSubmit(), S_StopAllSounds(), and S_StopChannel().

SndSys_SendKeyEvents()

void SndSys_SendKeyEvents

(

void

)

if the sound system can generate events, send them

Definition at line 150 of file snd_null.c.

{
}

SndSys_Shutdown()

void SndSys_Shutdown

(

void

)

Stop the sound card, delete "snd_renderbuffer" and free its other resources.

Definition at line 174 of file snd_sdl.c.

{
    if (audio_device > 0) {
        SDL_CloseAudioDevice(audio_device);
        audio_device = 0;
    }
    if (snd_renderbuffer != NULL)
    {
        Mem_Free(snd_renderbuffer->ring);
        Mem_Free(snd_renderbuffer);
        snd_renderbuffer = NULL;
    }
}

References audio_device, Mem_Free, NULL, and snd_renderbuffer.

Referenced by S_Shutdown().

SndSys_Submit()

void SndSys_Submit

(

void

)

Submit the contents of "snd_renderbuffer" to the sound card.

Definition at line 196 of file snd_sdl.c.

{
    // Nothing to do here (this sound module is callback-based)
}

Referenced by S_PaintAndSubmit().

SndSys_UnlockRenderBuffer()

void SndSys_UnlockRenderBuffer

(

void

)

Release the exclusive lock on "snd_renderbuffer".

Definition at line 236 of file snd_sdl.c.

{
    SDL_UnlockAudioDevice(audio_device);
}

References audio_device.

Referenced by S_PaintAndSubmit(), S_StopAllSounds(), and S_StopChannel().

Variable Documentation

channels

channel_t channels[MAX_CHANNELS]

extern

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

simsound

qbool simsound

extern

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_blocked

bool snd_blocked

extern

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

extern

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_channellayout

cvar_t snd_channellayout

extern

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_mempool

struct mempool_s* snd_mempool

extern

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_renderbuffer

snd_ringbuffer_t* snd_renderbuffer

extern

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_streaming

cvar_t snd_streaming

extern

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

extern

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_threaded

qbool snd_threaded

extern

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

extern

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

extern

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

total_channels

unsigned int total_channels

extern

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