/* snd_dma.c main control for any streaming sound output device Copyright (C) 1996-1997 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA */ #ifdef HAVE_CONFIG_H # include "config.h" #endif static __attribute__ ((used)) const char rcsid[] = "$Id$"; #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #include #include "winquake.h" #include "QF/cmd.h" #include "QF/cvar.h" #include "QF/dstring.h" #include "QF/model.h" #include "QF/qargs.h" #include "QF/sys.h" #include "QF/sound.h" #include "QF/plugin.h" #include "QF/va.h" #include "QF/quakefs.h" #include "snd_render.h" // Internal sound data & structures =========================================== volatile dma_t *snd_shm = 0; unsigned int snd_paintedtime; // sample PAIRS cvar_t *snd_loadas8bit; cvar_t *snd_volume; cvar_t *snd_interp; channel_t snd_channels[MAX_CHANNELS]; int snd_total_channels; static channel_t *ambient_channels[NUM_AMBIENTS]; static channel_t *dynamic_channels[MAX_DYNAMIC_CHANNELS]; static channel_t *static_channels[MAX_CHANNELS]; static int num_statics; static qboolean snd_initialized = false; static int snd_blocked = 0; static qboolean snd_ambient = 1; static vec3_t listener_origin; static vec3_t listener_forward; static vec3_t listener_right; static vec3_t listener_up; static vec_t sound_nominal_clip_dist = 1000.0; static unsigned soundtime; // sample PAIRS #define MAX_SFX 512 static sfx_t *known_sfx; // hunk allocated [MAX_SFX] static int num_sfx; static sfx_t *ambient_sfx[NUM_AMBIENTS]; static int sound_started = 0; static cvar_t *ambient_fade; static cvar_t *ambient_level; static cvar_t *nosound; static cvar_t *precache; static cvar_t *snd_mixahead; static cvar_t *snd_noextraupdate; static cvar_t *snd_phasesep; static cvar_t *snd_show; static cvar_t *snd_volumesep; static general_data_t plugin_info_general_data; static snd_render_data_t render_data = { 0, 0, 0, &soundtime, &snd_paintedtime, 0, }; static snd_output_funcs_t *snd_output_funcs; // User-setable variables ===================================================== // Fake dma is a synchronous faking of the DMA progress used for // isolating performance in the renderer. The fakedma_updates is // number of times s_update() is called per second. static qboolean fakedma = false; //static int fakedma_updates = 15; static void s_ambient_off (void) { snd_ambient = false; } static void s_ambient_on (void) { snd_ambient = true; } static void s_soundinfo_f (void) { if (!sound_started || !snd_shm) { Sys_Printf ("sound system not started\n"); return; } Sys_Printf ("%5d stereo\n", snd_shm->channels - 1); Sys_Printf ("%5d samples\n", snd_shm->samples); Sys_Printf ("%5d samplepos\n", snd_shm->samplepos); Sys_Printf ("%5d samplebits\n", snd_shm->samplebits); Sys_Printf ("%5d submission_chunk\n", snd_shm->submission_chunk); Sys_Printf ("%5d speed\n", snd_shm->speed); Sys_Printf ("0x%lx dma buffer\n", (unsigned long) snd_shm->buffer); Sys_Printf ("%5d total_channels\n", snd_total_channels); } static void s_startup (void) { if (!snd_initialized) return; if (!fakedma) { snd_shm = snd_output_funcs->pS_O_Init (); if (!snd_shm) { Sys_Printf ("S_Startup: S_O_Init failed.\n"); sound_started = 0; return; } } sound_started = 1; } // Load a sound =============================================================== static sfx_t * s_load_sound (const char *name) { int i; sfx_t *sfx; if (!known_sfx) return 0; // see if already loaded for (i = 0; i < num_sfx; i++) if (known_sfx[i].name && !strcmp (known_sfx[i].name, name)) { return &known_sfx[i]; } if (num_sfx == MAX_SFX) Sys_Error ("S_FindName: out of sfx_t"); sfx = &known_sfx[i]; if (sfx->name) free ((char *) sfx->name); sfx->name = strdup (name); SND_Load (sfx); num_sfx++; return sfx; } static void s_touch_sound (const char *name) { sfx_t *sfx; if (!sound_started) return; if (!name) Sys_Error ("s_touch_sound: NULL"); name = va ("sound/%s", name); sfx = s_load_sound (name); sfx->touch (sfx); } static sfx_t * s_precache_sound (const char *name) { sfx_t *sfx; if (!sound_started || nosound->int_val) return NULL; if (!name) Sys_Error ("s_precache_sound: NULL"); name = va ("sound/%s", name); sfx = s_load_sound (name); // cache it in if (precache->int_val) { if (sfx->retain (sfx)) sfx->release (sfx); } return sfx; } //============================================================================= static channel_t * s_alloc_channel (void) { if (snd_total_channels < MAX_CHANNELS) return &snd_channels[snd_total_channels++]; return 0; } static channel_t * s_pick_channel (int entnum, int entchannel) { int ch_idx; unsigned life_left; channel_t *ch, *first_to_die; // Check for replacement sound, or find the best one to replace first_to_die = 0; life_left = 0x7fffffff; for (ch_idx = 0; ch_idx < MAX_DYNAMIC_CHANNELS; ch_idx++) { ch = dynamic_channels[ch_idx]; if (entchannel != 0 // channel 0 never overrides && ch->entnum == entnum && (ch->entchannel == entchannel || entchannel == -1)) { // always override sound from same entity first_to_die = ch; break; } // don't let monster sounds override player sounds if (ch->entnum == *render_data.viewentity && entnum != *render_data.viewentity && ch->sfx) continue; if (snd_paintedtime + life_left > ch->end) { life_left = ch->end - snd_paintedtime; first_to_die = ch; } } if (!first_to_die) return NULL; if (first_to_die->sfx) { first_to_die->sfx->close (first_to_die->sfx); first_to_die->sfx = NULL; } return first_to_die; } static void s_spatialize (channel_t *ch) { int phase; // in samples vec_t dist, dot, lscale, rscale, scale; vec3_t source_vec; // anything coming from the view entity will always be full volume if (ch->entnum == *render_data.viewentity) { ch->leftvol = ch->master_vol; ch->rightvol = ch->master_vol; ch->phase = 0; return; } // calculate stereo seperation and distance attenuation VectorSubtract (ch->origin, listener_origin, source_vec); dist = VectorNormalize (source_vec) * ch->dist_mult; dot = DotProduct (listener_right, source_vec); if (snd_shm->channels == 1) { rscale = 1.0; lscale = 1.0; phase = 0; } else { rscale = 1.0 + dot * snd_volumesep->value; lscale = 1.0 - dot * snd_volumesep->value; phase = snd_phasesep->value * 0.001 * snd_shm->speed * dot; } // add in distance effect scale = (1.0 - dist) * rscale; ch->rightvol = (int) (ch->master_vol * scale); if (ch->rightvol < 0) ch->rightvol = 0; scale = (1.0 - dist) * lscale; ch->leftvol = (int) (ch->master_vol * scale); if (ch->leftvol < 0) ch->leftvol = 0; ch->phase = phase; } // Start a sound effect ======================================================= static void s_start_sound (int entnum, int entchannel, sfx_t *sfx, const vec3_t origin, float fvol, float attenuation) { int ch_idx, vol; unsigned int skip; channel_t *target_chan, *check; if (!sound_started) return; if (!sfx) return; if (nosound->int_val) return; // pick a channel to play on target_chan = s_pick_channel (entnum, entchannel); if (!target_chan) return; vol = fvol * 255; // spatialize memset (target_chan, 0, sizeof (*target_chan)); VectorCopy (origin, target_chan->origin); target_chan->dist_mult = attenuation / sound_nominal_clip_dist; target_chan->master_vol = vol; target_chan->entnum = entnum; target_chan->entchannel = entchannel; s_spatialize (target_chan); if (!target_chan->leftvol && !target_chan->rightvol) return; // not audible at all // new channel if (!sfx->retain (sfx)) { if (target_chan->sfx) target_chan->sfx->close (target_chan->sfx); target_chan->sfx = NULL; return; // couldn't load the sound's data } if (!(target_chan->sfx = sfx->open (sfx))) { sfx->release (sfx); return; } target_chan->pos = 0.0; target_chan->end = snd_paintedtime + target_chan->sfx->length; sfx->release (sfx); // 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 for (ch_idx = 0; ch_idx < MAX_DYNAMIC_CHANNELS; ch_idx++) { check = dynamic_channels[ch_idx]; if (check == target_chan) continue; if (check->sfx == sfx && !check->pos) { skip = rand () % (int) (0.1 * snd_shm->speed); if (skip >= target_chan->end) skip = target_chan->end - 1; target_chan->pos += skip; target_chan->end -= skip; break; } } } static void s_stop_sound (int entnum, int entchannel) { int i; channel_t *ch; if (!sound_started) return; for (i = 0; i < MAX_DYNAMIC_CHANNELS; i++) { ch = dynamic_channels[i]; if (ch->entnum == entnum && ch->entchannel == entchannel) { ch->end = 0; if (ch->sfx) ch->sfx->close (ch->sfx); ch->sfx = NULL; return; } } } static void s_clear_buffer (void) { int clear, i; if (!sound_started || !snd_shm || !snd_shm->buffer) return; if (snd_shm->samplebits == 8) clear = 0x80; else clear = 0; for (i = 0; i < snd_shm->samples * snd_shm->samplebits / 8; i++) snd_shm->buffer[i] = 0; } static void s_stop_all_sounds (qboolean clear) { int i; if (!sound_started) return; num_statics = 0; for (i = 0; i < MAX_CHANNELS; i++) if (snd_channels[i].sfx) { snd_channels[i].sfx->close (snd_channels[i].sfx); snd_channels[i].sfx = NULL; } memset (snd_channels, 0, MAX_CHANNELS * sizeof (channel_t)); if (clear) s_clear_buffer (); } static void s_stop_all_sounds_f (void) { s_stop_all_sounds (true); } static void s_static_sound (sfx_t *sfx, const vec3_t origin, float vol, float attenuation) { channel_t *ss; if (!sound_started || !sfx) return; if (!static_channels[num_statics]) { if (!(static_channels[num_statics] = s_alloc_channel ())) { Sys_Printf ("ran out of channels\n"); return; } } ss = static_channels[num_statics]; if (!sfx->retain (sfx)) return; if (sfx->loopstart == (unsigned int) -1) { Sys_Printf ("Sound %s not looped\n", sfx->name); sfx->release (sfx); return; } if (!(ss->sfx = sfx->open (sfx))) { sfx->release (sfx); return; } VectorCopy (origin, ss->origin); ss->master_vol = vol; ss->dist_mult = (attenuation / 64) / sound_nominal_clip_dist; ss->end = snd_paintedtime + sfx->length; sfx->release (sfx); s_spatialize (ss); ss->oldphase = ss->phase; num_statics++; } //============================================================================= static void s_updateAmbientSounds (void) { float vol; int ambient_channel; channel_t *chan; mleaf_t *l; if (!snd_ambient) return; // calc ambient sound levels if (!*render_data.worldmodel) return; l = Mod_PointInLeaf (listener_origin, *render_data.worldmodel); if (!l || !ambient_level->value) { for (ambient_channel = 0; ambient_channel < NUM_AMBIENTS; ambient_channel++) { chan = ambient_channels[ambient_channel]; if (chan->sfx) chan->sfx->close (chan->sfx); chan->sfx = NULL; } return; } for (ambient_channel = 0; ambient_channel < NUM_AMBIENTS; ambient_channel++) { chan = ambient_channels[ambient_channel]; if (!ambient_sfx[ambient_channel]) { chan->sfx = 0; continue; } else if (!chan->sfx) chan->sfx = ambient_sfx[ambient_channel]->open (ambient_sfx[ambient_channel]); vol = ambient_level->value * l->ambient_sound_level[ambient_channel]; if (vol < 8) vol = 0; // don't adjust volume too fast if (chan->master_vol < vol) { chan->master_vol += *render_data.host_frametime * ambient_fade->value; if (chan->master_vol > vol) chan->master_vol = vol; } else if (chan->master_vol > vol) { chan->master_vol -= *render_data.host_frametime * ambient_fade->value; if (chan->master_vol < vol) chan->master_vol = vol; } chan->leftvol = chan->rightvol = chan->master_vol; } } static void s_get_soundtime (void) { int fullsamples, samplepos; static int buffers, oldsamplepos; fullsamples = snd_shm->samples / snd_shm->channels; // it is possible to miscount buffers if it has wrapped twice between // calls to s_update. Oh well. if ((samplepos = snd_output_funcs->pS_O_GetDMAPos ()) == -1) return; if (samplepos < oldsamplepos) { buffers++; // buffer wrapped if (snd_paintedtime > 0x40000000) { // time to chop things off to avoid // 32 bit limits buffers = 0; snd_paintedtime = fullsamples; s_stop_all_sounds (true); } } oldsamplepos = samplepos; soundtime = buffers * fullsamples + samplepos / snd_shm->channels; } static void s_update_ (void) { unsigned int endtime, samps; if (!sound_started || (snd_blocked > 0)) return; // Updates DMA time s_get_soundtime (); // check to make sure that we haven't overshot if (snd_paintedtime < soundtime) { // Sys_Printf ("S_Update_ : overflow\n"); snd_paintedtime = soundtime; } // mix ahead of current position endtime = soundtime + snd_mixahead->value * snd_shm->speed; samps = snd_shm->samples >> (snd_shm->channels - 1); if (endtime - soundtime > samps) endtime = soundtime + samps; SND_PaintChannels (endtime); snd_output_funcs->pS_O_Submit (); } static inline int s_update_channel (channel_t *ch) { if (!ch->sfx) return 0; ch->oldphase = ch->phase; // prepare to lerp from prev to next phase s_spatialize (ch); // respatialize channel if (!ch->leftvol && !ch->rightvol) return 0; return 1; } /* s_update Called once each time through the main loop */ static void s_update (const vec3_t origin, const vec3_t forward, const vec3_t right, const vec3_t up) { int total, i, j; channel_t *ch, *combine; if (!sound_started || (snd_blocked > 0)) return; VectorCopy (origin, listener_origin); VectorCopy (forward, listener_forward); VectorCopy (right, listener_right); VectorCopy (up, listener_up); // update general area ambient sound sources s_updateAmbientSounds (); combine = NULL; // update spatialization for static and dynamic sounds for (i = 0; i < MAX_DYNAMIC_CHANNELS; i++) s_update_channel (dynamic_channels[i]); for (i = 0; i < num_statics; i++) { ch = static_channels[i]; if (!s_update_channel (ch)) continue; // try to combine static sounds with a previous channel of the same // sound effect so we don't mix five torches every frame // see if it can just use the last one if (combine && combine->sfx == ch->sfx) { combine->leftvol += ch->leftvol; combine->rightvol += ch->rightvol; ch->leftvol = ch->rightvol = 0; continue; } // search for one for (j = 0; j < i; j++) { combine = static_channels[j]; if (combine->sfx == ch->sfx) break; } if (j == i) { combine = NULL; } else { if (combine != ch) { combine->leftvol += ch->leftvol; combine->rightvol += ch->rightvol; ch->leftvol = ch->rightvol = 0; } continue; } } // debugging output if (snd_show->int_val) { total = 0; ch = snd_channels; for (i = 0; i < snd_total_channels; i++, ch++) if (ch->sfx && (ch->leftvol || ch->rightvol)) { // Sys_Printf ("%3i %3i %s\n", ch->leftvol, ch->rightvol, // ch->sfx->name); total++; } Sys_Printf ("----(%i)----\n", total); } // mix some sound s_update_ (); } static void s_extra_update (void) { if (!sound_started || snd_noextraupdate->int_val) return; // don't pollute timings s_update_ (); } /* console functions */ static void s_play (void) { dstring_t *name = dstring_new (); int i; static int hash = 345; sfx_t *sfx; i = 1; while (i < Cmd_Argc ()) { if (!strrchr (Cmd_Argv (i), '.')) { dsprintf (name, "%s.wav", Cmd_Argv (i)); } else { dsprintf (name, "%s", Cmd_Argv (i)); } sfx = s_precache_sound (name->str); s_start_sound (hash++, 0, sfx, listener_origin, 1.0, 1.0); i++; } dstring_delete (name); } static void s_playcenter_f (void) { dstring_t *name = dstring_new (); int i; sfx_t *sfx; i = 1; while (i < Cmd_Argc ()) { if (!strrchr (Cmd_Argv (i), '.')) { dsprintf (name, "%s.wav", Cmd_Argv (i)); } else { dsprintf (name, "%s", Cmd_Argv (i)); } sfx = s_precache_sound (name->str); s_start_sound (*render_data.viewentity, 0, sfx, listener_origin, 1.0, 1.0); i++; } dstring_delete (name); } static void s_playvol_f (void) { dstring_t *name = dstring_new (); float vol; int i; static int hash = 543; sfx_t *sfx; i = 1; while (i < Cmd_Argc ()) { if (!strrchr (Cmd_Argv (i), '.')) { dsprintf (name, "%s.wav", Cmd_Argv (i)); } else { dsprintf (name, "%s", Cmd_Argv (i)); } sfx = s_precache_sound (name->str); vol = atof (Cmd_Argv (i + 1)); s_start_sound (hash++, 0, sfx, listener_origin, vol, 1.0); i += 2; } dstring_delete (name); } static void s_soundlist_f (void) { int load, total, i; sfx_t *sfx; if (Cmd_Argc() >= 2 && Cmd_Argv (1)[0]) load = 1; else load = 0; total = 0; for (sfx = known_sfx, i = 0; i < num_sfx; i++, sfx++) { if (load) { if (!sfx->retain (sfx)) continue; } else { if (!sfx->touch (sfx)) continue; } total += sfx->length; Sys_Printf ("%6d %6d %s\n", sfx->loopstart, sfx->length, sfx->name); if (load) sfx->release (sfx); } Sys_Printf ("Total resident: %i\n", total); } static void s_local_sound (const char *sound) { sfx_t *sfx; if (!sound_started) return; if (nosound->int_val) return; sfx = s_precache_sound (sound); if (!sfx) { Sys_Printf ("S_LocalSound: can't cache %s\n", sound); return; } s_start_sound (*render_data.viewentity, -1, sfx, vec3_origin, 1, 1); } static void s_clear_precache (void) { } static void s_begin_precaching (void) { } static void s_end_precaching (void) { } static void s_block_sound (void) { if (++snd_blocked == 1) { snd_output_funcs->pS_O_BlockSound (); s_clear_buffer (); } } static void s_unblock_sound (void) { if (!snd_blocked) return; if (!--snd_blocked) { s_clear_buffer (); snd_output_funcs->pS_O_UnblockSound (); } } static void s_gamedir (void) { num_sfx = 0; } static void s_init (void) { int i; for (i = 0; i < NUM_AMBIENTS; i++) ambient_channels[i] = s_alloc_channel (); for (i = 0; i < MAX_DYNAMIC_CHANNELS; i++) dynamic_channels[i] = s_alloc_channel (); snd_output_funcs = render_data.output->functions->snd_output; Sys_Printf ("\nSound Initialization\n"); Cmd_AddCommand ("play", s_play, "Play selected sound effect (play pathto/sound.wav)"); Cmd_AddCommand ("playcenter", s_playcenter_f, "Play selected sound effect without 3D spatialization."); Cmd_AddCommand ("playvol", s_playvol_f, "Play selected sound effect at " "selected volume (playvol pathto/sound.wav num"); Cmd_AddCommand ("stopsound", s_stop_all_sounds_f, "Stops all sounds currently being played"); Cmd_AddCommand ("soundlist", s_soundlist_f, "Reports a list of sounds in the cache"); Cmd_AddCommand ("soundinfo", s_soundinfo_f, "Report information on the sound system"); snd_interp = Cvar_Get ("snd_interp", "1", CVAR_ARCHIVE, NULL, "control sample interpolation"); ambient_fade = Cvar_Get ("ambient_fade", "100", CVAR_NONE, NULL, "How quickly ambient sounds fade in or out"); ambient_level = Cvar_Get ("ambient_level", "0.3", CVAR_NONE, NULL, "Ambient sounds' volume"); nosound = Cvar_Get ("nosound", "0", CVAR_NONE, NULL, "Set to turn sound off"); precache = Cvar_Get ("precache", "1", CVAR_NONE, NULL, "Toggle the use of a precache"); snd_volume = Cvar_Get ("volume", "0.7", CVAR_ARCHIVE, NULL, "Set the volume for sound playback"); snd_interp = Cvar_Get ("snd_interp", "1", CVAR_ARCHIVE, NULL, "control sample interpolation"); snd_loadas8bit = Cvar_Get ("snd_loadas8bit", "0", CVAR_NONE, NULL, "Toggles loading sounds as 8-bit samples"); snd_mixahead = Cvar_Get ("snd_mixahead", "0.1", CVAR_ARCHIVE, NULL, "Delay time for sounds"); snd_noextraupdate = Cvar_Get ("snd_noextraupdate", "0", CVAR_NONE, NULL, "Toggles the correct value display in " "host_speeds. Usually messes up sound " "playback when in effect"); snd_phasesep = Cvar_Get ("snd_phasesep", "0.0", CVAR_ARCHIVE, NULL, "max stereo phase separation in ms. 0.6 is for " "20cm head"); snd_show = Cvar_Get ("snd_show", "0", CVAR_NONE, NULL, "Toggles display of sounds currently being played"); snd_volumesep = Cvar_Get ("snd_volumesep", "1.0", CVAR_ARCHIVE, NULL, "max stereo volume separation. 1.0 is max"); if (COM_CheckParm ("-nosound")) return; if (COM_CheckParm ("-simsound")) fakedma = true; // FIXME // if (host_parms.memsize < 0x800000) { // Cvar_Set (snd_loadas8bit, "1"); // Sys_Printf ("loading all sounds as 8bit\n"); // } snd_initialized = true; s_startup (); if (sound_started == 0) // sound startup failed? Bail out. return; SND_InitScaletable (); known_sfx = Hunk_AllocName (MAX_SFX * sizeof (sfx_t), "sfx_t"); num_sfx = 0; // create a piece of DMA memory if (fakedma) { snd_shm = (void *) Hunk_AllocName (sizeof (*snd_shm), "snd_shm"); snd_shm->samplebits = 16; snd_shm->speed = 22050; snd_shm->channels = 2; snd_shm->samples = 32768; snd_shm->samplepos = 0; snd_shm->submission_chunk = 1; snd_shm->buffer = Hunk_AllocName (1 << 16, "shmbuf"); } // Sys_Printf ("Sound sampling rate: %i\n", snd_shm->speed); // provides a tick sound until washed clean // if (snd_shm->buffer) // snd_shm->buffer[4] = snd_shm->buffer[5] = 0x7f; // force a pop for debugging ambient_sfx[AMBIENT_WATER] = s_precache_sound ("ambience/water1.wav"); ambient_sfx[AMBIENT_SKY] = s_precache_sound ("ambience/wind2.wav"); s_stop_all_sounds (true); QFS_GamedirCallback (s_gamedir); } // Shutdown sound engine ====================================================== static void s_shutdown (void) { if (!sound_started) return; sound_started = 0; if (!fakedma) { snd_output_funcs->pS_O_Shutdown (); } snd_shm = 0; } static general_funcs_t plugin_info_general_funcs = { s_init, s_shutdown, }; static snd_render_funcs_t plugin_info_render_funcs = { s_ambient_off, s_ambient_on, s_touch_sound, s_static_sound, s_start_sound, s_stop_sound, s_precache_sound, s_clear_precache, s_update, s_stop_all_sounds, s_begin_precaching, s_end_precaching, s_extra_update, s_local_sound, s_block_sound, s_unblock_sound, s_load_sound, s_alloc_channel, }; static plugin_funcs_t plugin_info_funcs = { &plugin_info_general_funcs, 0, 0, 0, 0, &plugin_info_render_funcs, }; static plugin_data_t plugin_info_data = { &plugin_info_general_data, 0, 0, 0, 0, &render_data, }; static plugin_t plugin_info = { qfp_snd_render, 0, QFPLUGIN_VERSION, "0.1", "Sound Renderer", "Copyright (C) 1996-1997 id Software, Inc.\n" "Copyright (C) 1999,2000,2001 contributors of the QuakeForge " "project\n" "Please see the file \"AUTHORS\" for a list of contributors", &plugin_info_funcs, &plugin_info_data, }; PLUGIN_INFO(snd_render, default) { return &plugin_info; }