]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - snd_main.c
fix cs_project and cs_unproject builtins, they were completely ignoring
[xonotic/darkplaces.git] / snd_main.c
index 35be85edfb16f6f82c7a5bc95bf979f8d3fb5742..a0e376c216e9f3fbe5b801bb833481045d95e065 100644 (file)
@@ -140,10 +140,12 @@ channel_t channels[MAX_CHANNELS];
 unsigned int total_channels;
 
 snd_ringbuffer_t *snd_renderbuffer = NULL;
-unsigned int soundtime = 0;
+static unsigned int soundtime = 0;
 static unsigned int oldpaintedtime = 0;
 static unsigned int extrasoundtime = 0;
 static double snd_starttime = 0.0;
+qboolean snd_threaded = false;
+qboolean snd_usethreadedmixing = false;
 
 vec3_t listener_origin;
 matrix4x4_t listener_matrix[SND_LISTENERS];
@@ -177,6 +179,38 @@ cvar_t snd_swapstereo = {CVAR_SAVE, "snd_swapstereo", "0", "swaps left/right spe
 extern cvar_t v_flipped;
 cvar_t snd_channellayout = {0, "snd_channellayout", "0", "channel layout. Can be 0 (auto - snd_restart needed), 1 (standard layout), or 2 (ALSA layout)"};
 cvar_t snd_mutewhenidle = {CVAR_SAVE, "snd_mutewhenidle", "1", "whether to disable sound output when game window is inactive"};
+cvar_t snd_entchannel0volume = {CVAR_SAVE, "snd_entchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of regular entities"};
+cvar_t snd_entchannel1volume = {CVAR_SAVE, "snd_entchannel1volume", "1", "volume multiplier of the 1st entity channel of regular entities"};
+cvar_t snd_entchannel2volume = {CVAR_SAVE, "snd_entchannel2volume", "1", "volume multiplier of the 2nd entity channel of regular entities"};
+cvar_t snd_entchannel3volume = {CVAR_SAVE, "snd_entchannel3volume", "1", "volume multiplier of the 3rd entity channel of regular entities"};
+cvar_t snd_entchannel4volume = {CVAR_SAVE, "snd_entchannel4volume", "1", "volume multiplier of the 4th entity channel of regular entities"};
+cvar_t snd_entchannel5volume = {CVAR_SAVE, "snd_entchannel5volume", "1", "volume multiplier of the 5th entity channel of regular entities"};
+cvar_t snd_entchannel6volume = {CVAR_SAVE, "snd_entchannel6volume", "1", "volume multiplier of the 6th entity channel of regular entities"};
+cvar_t snd_entchannel7volume = {CVAR_SAVE, "snd_entchannel7volume", "1", "volume multiplier of the 7th entity channel of regular entities"};
+cvar_t snd_playerchannel0volume = {CVAR_SAVE, "snd_playerchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of player entities"};
+cvar_t snd_playerchannel1volume = {CVAR_SAVE, "snd_playerchannel1volume", "1", "volume multiplier of the 1st entity channel of player entities"};
+cvar_t snd_playerchannel2volume = {CVAR_SAVE, "snd_playerchannel2volume", "1", "volume multiplier of the 2nd entity channel of player entities"};
+cvar_t snd_playerchannel3volume = {CVAR_SAVE, "snd_playerchannel3volume", "1", "volume multiplier of the 3rd entity channel of player entities"};
+cvar_t snd_playerchannel4volume = {CVAR_SAVE, "snd_playerchannel4volume", "1", "volume multiplier of the 4th entity channel of player entities"};
+cvar_t snd_playerchannel5volume = {CVAR_SAVE, "snd_playerchannel5volume", "1", "volume multiplier of the 5th entity channel of player entities"};
+cvar_t snd_playerchannel6volume = {CVAR_SAVE, "snd_playerchannel6volume", "1", "volume multiplier of the 6th entity channel of player entities"};
+cvar_t snd_playerchannel7volume = {CVAR_SAVE, "snd_playerchannel7volume", "1", "volume multiplier of the 7th entity channel of player entities"};
+cvar_t snd_worldchannel0volume = {CVAR_SAVE, "snd_worldchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of the world entity"};
+cvar_t snd_worldchannel1volume = {CVAR_SAVE, "snd_worldchannel1volume", "1", "volume multiplier of the 1st entity channel of the world entity"};
+cvar_t snd_worldchannel2volume = {CVAR_SAVE, "snd_worldchannel2volume", "1", "volume multiplier of the 2nd entity channel of the world entity"};
+cvar_t snd_worldchannel3volume = {CVAR_SAVE, "snd_worldchannel3volume", "1", "volume multiplier of the 3rd entity channel of the world entity"};
+cvar_t snd_worldchannel4volume = {CVAR_SAVE, "snd_worldchannel4volume", "1", "volume multiplier of the 4th entity channel of the world entity"};
+cvar_t snd_worldchannel5volume = {CVAR_SAVE, "snd_worldchannel5volume", "1", "volume multiplier of the 5th entity channel of the world entity"};
+cvar_t snd_worldchannel6volume = {CVAR_SAVE, "snd_worldchannel6volume", "1", "volume multiplier of the 6th entity channel of the world entity"};
+cvar_t snd_worldchannel7volume = {CVAR_SAVE, "snd_worldchannel7volume", "1", "volume multiplier of the 7th entity channel of the world entity"};
+cvar_t snd_csqcchannel0volume = {CVAR_SAVE, "snd_csqcchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of the world entity"};
+cvar_t snd_csqcchannel1volume = {CVAR_SAVE, "snd_csqcchannel1volume", "1", "volume multiplier of the 1st entity channel of the world entity"};
+cvar_t snd_csqcchannel2volume = {CVAR_SAVE, "snd_csqcchannel2volume", "1", "volume multiplier of the 2nd entity channel of the world entity"};
+cvar_t snd_csqcchannel3volume = {CVAR_SAVE, "snd_csqcchannel3volume", "1", "volume multiplier of the 3rd entity channel of the world entity"};
+cvar_t snd_csqcchannel4volume = {CVAR_SAVE, "snd_csqcchannel4volume", "1", "volume multiplier of the 4th entity channel of the world entity"};
+cvar_t snd_csqcchannel5volume = {CVAR_SAVE, "snd_csqcchannel5volume", "1", "volume multiplier of the 5th entity channel of the world entity"};
+cvar_t snd_csqcchannel6volume = {CVAR_SAVE, "snd_csqcchannel6volume", "1", "volume multiplier of the 6th entity channel of the world entity"};
+cvar_t snd_csqcchannel7volume = {CVAR_SAVE, "snd_csqcchannel7volume", "1", "volume multiplier of the 7th entity channel of the world entity"};
 
 // Local cvars
 static cvar_t nosound = {0, "nosound", "0", "disables sound"};
@@ -469,7 +503,10 @@ void S_Startup (void)
        qboolean fixed_speed, fixed_width, fixed_channels;
        snd_format_t chosen_fmt;
        static snd_format_t prev_render_format = {0, 0, 0};
-       const char* env;
+       char* env;
+#if _MSC_VER >= 1400
+       size_t envlen;
+#endif
        int i;
 
        if (!snd_initialized.integer)
@@ -485,22 +522,43 @@ void S_Startup (void)
        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
                fixed_channels = true;
        }
+#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
                fixed_speed = true;
        }
+#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
                fixed_width = true;
        }
 
@@ -712,6 +770,38 @@ void S_Init(void)
        Cvar_RegisterVariable(&volume);
        Cvar_RegisterVariable(&bgmvolume);
        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_speed);
        Cvar_RegisterVariable(&snd_width);
@@ -894,7 +984,7 @@ void S_FreeSfx (sfx_t *sfx, qboolean force)
        // Stop all channels using this sfx
        for (i = 0; i < total_channels; i++)
                if (channels[i].sfx == sfx)
-                       S_StopChannel (i);
+                       S_StopChannel (i, true);
 
        // Free it
        if (sfx->fetcher != NULL && sfx->fetcher->free != NULL)
@@ -1080,7 +1170,7 @@ channel_t *SND_PickChannel(int entnum, int entchannel)
                        if (ch->entnum == entnum && (ch->entchannel == entchannel || entchannel == -1) )
                        {
                                // always override sound from same entity
-                               S_StopChannel (ch_idx);
+                               S_StopChannel (ch_idx, true);
                                return &channels[ch_idx];
                        }
                }
@@ -1150,9 +1240,73 @@ void SND_Spatialize(channel_t *ch, qboolean isstatic)
        }
 
        mastervol = ch->master_vol;
+
        // Adjust volume of static sounds
        if (isstatic)
                mastervol *= snd_staticvolume.value;
+       else if(!(ch->flags & CHANNELFLAG_FULLVOLUME)) // same as SND_PaintChannel uses
+       {
+               if(ch->entnum >= 32768)
+               {
+                       switch(ch->entchannel)
+                       {
+                               case 0: mastervol *= snd_csqcchannel0volume.value; break;
+                               case 1: mastervol *= snd_csqcchannel1volume.value; break;
+                               case 2: mastervol *= snd_csqcchannel2volume.value; break;
+                               case 3: mastervol *= snd_csqcchannel3volume.value; break;
+                               case 4: mastervol *= snd_csqcchannel4volume.value; break;
+                               case 5: mastervol *= snd_csqcchannel5volume.value; break;
+                               case 6: mastervol *= snd_csqcchannel6volume.value; break;
+                               case 7: mastervol *= snd_csqcchannel7volume.value; break;
+                               default:                                           break;
+                       }
+               }
+               else if(ch->entnum == 0)
+               {
+                       switch(ch->entchannel)
+                       {
+                               case 0: mastervol *= snd_worldchannel0volume.value; break;
+                               case 1: mastervol *= snd_worldchannel1volume.value; break;
+                               case 2: mastervol *= snd_worldchannel2volume.value; break;
+                               case 3: mastervol *= snd_worldchannel3volume.value; break;
+                               case 4: mastervol *= snd_worldchannel4volume.value; break;
+                               case 5: mastervol *= snd_worldchannel5volume.value; break;
+                               case 6: mastervol *= snd_worldchannel6volume.value; break;
+                               case 7: mastervol *= snd_worldchannel7volume.value; break;
+                               default:                                            break;
+                       }
+               }
+               else if(ch->entnum > 0 && ch->entnum <= cl.maxclients)
+               {
+                       switch(ch->entchannel)
+                       {
+                               case 0: mastervol *= snd_playerchannel0volume.value; break;
+                               case 1: mastervol *= snd_playerchannel1volume.value; break;
+                               case 2: mastervol *= snd_playerchannel2volume.value; break;
+                               case 3: mastervol *= snd_playerchannel3volume.value; break;
+                               case 4: mastervol *= snd_playerchannel4volume.value; break;
+                               case 5: mastervol *= snd_playerchannel5volume.value; break;
+                               case 6: mastervol *= snd_playerchannel6volume.value; break;
+                               case 7: mastervol *= snd_playerchannel7volume.value; break;
+                               default:                                             break;
+                       }
+               }
+               else
+               {
+                       switch(ch->entchannel)
+                       {
+                               case 0: mastervol *= snd_entchannel0volume.value; break;
+                               case 1: mastervol *= snd_entchannel1volume.value; break;
+                               case 2: mastervol *= snd_entchannel2volume.value; break;
+                               case 3: mastervol *= snd_entchannel3volume.value; break;
+                               case 4: mastervol *= snd_entchannel4volume.value; break;
+                               case 5: mastervol *= snd_entchannel5volume.value; break;
+                               case 6: mastervol *= snd_entchannel6volume.value; break;
+                               case 7: mastervol *= snd_entchannel7volume.value; break;
+                               default:                                          break;
+                       }
+               }
+       }
 
        // anything coming from the view entity will always be full volume
        // LordHavoc: make sounds with ATTN_NONE have no spatialization
@@ -1194,9 +1348,10 @@ void SND_Spatialize(channel_t *ch, qboolean isstatic)
 void S_PlaySfxOnChannel (sfx_t *sfx, channel_t *target_chan, unsigned int flags, vec3_t origin, float fvol, float attenuation, qboolean isstatic)
 {
        // Initialize the channel
+       // We MUST set sfx LAST because otherwise we could crash a threaded mixer
+       // (otherwise we'd have to call SndSys_LockRenderBuffer here)
        memset (target_chan, 0, sizeof (*target_chan));
        VectorCopy (origin, target_chan->origin);
-       target_chan->sfx = sfx;
        target_chan->flags = flags;
        target_chan->pos = 0; // start of the sound
 
@@ -1213,7 +1368,12 @@ void S_PlaySfxOnChannel (sfx_t *sfx, channel_t *target_chan, unsigned int flags,
        // Lock the SFX during play
        S_LockSfx (sfx);
 
-       // and finally, apply the volume
+       // finally, set the sfx pointer, so the channel becomes valid for playback
+       // and will be noticed by the mixer
+       target_chan->sfx = sfx;
+
+       // we have to set the channel volume AFTER the sfx because the function
+       // needs it for replaygain support
        S_SetChannelVolume(target_chan - channels, fvol);
 }
 
@@ -1258,7 +1418,7 @@ int S_StartSound (int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float f
        return (target_chan - channels);
 }
 
-void S_StopChannel (unsigned int channel_ind)
+void S_StopChannel (unsigned int channel_ind, qboolean lockmutex)
 {
        channel_t *ch;
 
@@ -1270,6 +1430,12 @@ void S_StopChannel (unsigned int channel_ind)
        {
                sfx_t *sfx = ch->sfx;
 
+               // 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)
+                       SndSys_LockRenderBuffer();
                if (sfx->fetcher != NULL)
                {
                        snd_fetcher_endsb_t fetcher_endsb = sfx->fetcher->endsb;
@@ -1282,6 +1448,8 @@ void S_StopChannel (unsigned int channel_ind)
 
                ch->fetcher_data = NULL;
                ch->sfx = NULL;
+               if (lockmutex)
+                       SndSys_UnlockRenderBuffer();
        }
 }
 
@@ -1311,7 +1479,7 @@ void S_StopSound(int entnum, int entchannel)
        for (i = 0; i < MAX_DYNAMIC_CHANNELS; i++)
                if (channels[i].entnum == entnum && channels[i].entchannel == entchannel)
                {
-                       S_StopChannel (i);
+                       S_StopChannel (i, true);
                        return;
                }
 }
@@ -1329,7 +1497,7 @@ void S_StopAllSounds (void)
        CDAudio_Stop();
 
        for (i = 0; i < total_channels; i++)
-               S_StopChannel (i);
+               S_StopChannel (i, true);
 
        total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS;   // no statics
        memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));
@@ -1463,24 +1631,36 @@ void S_UpdateAmbientSounds (void)
 static void S_PaintAndSubmit (void)
 {
        unsigned int newsoundtime, paintedtime, endtime, maxtime, usedframes;
-       qboolean usesoundtimehack;
-       static qboolean soundtimehack = true;
+       int usesoundtimehack;
+       static int soundtimehack = -1;
+       static int oldsoundtime = 0;
 
        if (snd_renderbuffer == NULL || nosound.integer)
                return;
 
        // Update sound time
+       snd_usethreadedmixing = false;
        usesoundtimehack = true;
        if (cls.timedemo) // SUPER NASTY HACK to mix non-realtime sound for more reliable benchmarking
+       {
+               usesoundtimehack = 1;
                newsoundtime = (unsigned int)((double)cl.mtime[0] * (double)snd_renderbuffer->format.speed);
+       }
        else if (cls.capturevideo.soundrate && !cls.capturevideo.realtime) // SUPER NASTY HACK to record non-realtime sound
+       {
+               usesoundtimehack = 2;
                newsoundtime = (unsigned int)((double)cls.capturevideo.frame * (double)snd_renderbuffer->format.speed / (double)cls.capturevideo.framerate);
+       }
        else if (simsound)
+       {
+               usesoundtimehack = 3;
                newsoundtime = (unsigned int)((realtime - snd_starttime) * (double)snd_renderbuffer->format.speed);
+       }
        else
        {
+               snd_usethreadedmixing = snd_threaded && !cls.capturevideo.soundrate;
+               usesoundtimehack = 0;
                newsoundtime = SndSys_GetSoundTime();
-               usesoundtimehack = false;
        }
        // if the soundtimehack state changes we need to reset the soundtime
        if (soundtimehack != usesoundtimehack)
@@ -1506,6 +1686,9 @@ static void S_PaintAndSubmit (void)
        if (!soundtimehack && snd_blocked > 0)
                return;
 
+       if (snd_usethreadedmixing)
+               return; // the audio thread will mix its own data
+
        newsoundtime += extrasoundtime;
        if (newsoundtime < soundtime)
        {
@@ -1533,23 +1716,60 @@ static void S_PaintAndSubmit (void)
        soundtime = newsoundtime;
        recording_sound = (cls.capturevideo.soundrate != 0);
 
+       // Lock submitbuffer
+       if (!simsound && !SndSys_LockRenderBuffer())
+       {
+               // If the lock failed, stop here
+               Con_DPrint(">> S_PaintAndSubmit: SndSys_LockRenderBuffer() failed\n");
+               return;
+       }
+
        // Check to make sure that we haven't overshot
        paintedtime = snd_renderbuffer->endframe;
        if (paintedtime < soundtime)
                paintedtime = soundtime;
 
        // mix ahead of current position
-       endtime = soundtime + (unsigned int)(_snd_mixahead.value * (float)snd_renderbuffer->format.speed);
+       if (soundtimehack)
+               endtime = soundtime + (unsigned int)(_snd_mixahead.value * (float)snd_renderbuffer->format.speed);
+       else
+               endtime = soundtime + (unsigned int)(max(_snd_mixahead.value * (float)snd_renderbuffer->format.speed, min(3 * (soundtime - oldsoundtime), 0.3 * (float)snd_renderbuffer->format.speed)));
        usedframes = snd_renderbuffer->endframe - snd_renderbuffer->startframe;
        maxtime = paintedtime + snd_renderbuffer->maxframes - usedframes;
        endtime = min(endtime, maxtime);
 
-       S_PaintChannels(snd_renderbuffer, paintedtime, endtime);
+       while (paintedtime < endtime)
+       {
+               unsigned int startoffset;
+               unsigned int nbframes;
+
+               // see how much we can fit in the paint buffer
+               nbframes = endtime - paintedtime;
+               // limit to the end of the ring buffer (in case of wrapping)
+               startoffset = paintedtime % snd_renderbuffer->maxframes;
+               nbframes = min(nbframes, snd_renderbuffer->maxframes - startoffset);
+
+               // mix into the buffer
+               S_MixToBuffer(&snd_renderbuffer->ring[startoffset * snd_renderbuffer->format.width * snd_renderbuffer->format.channels], nbframes);
+
+               paintedtime += nbframes;
+               snd_renderbuffer->endframe = paintedtime;
+       }
+       if (!simsound)
+               SndSys_UnlockRenderBuffer();
+
+       // Remove outdated samples from the ring buffer, if any
+       if (snd_renderbuffer->startframe < soundtime)
+               snd_renderbuffer->startframe = soundtime;
 
        if (simsound)
                snd_renderbuffer->startframe = snd_renderbuffer->endframe;
        else
                SndSys_Submit();
+
+       oldsoundtime = soundtime;
+
+       cls.soundstats.latency_milliseconds = (snd_renderbuffer->endframe - snd_renderbuffer->startframe) * 1000 / snd_renderbuffer->format.speed;
 }
 
 /*
@@ -1561,7 +1781,7 @@ Called once each time through the main loop
 */
 void S_Update(const matrix4x4_t *listenermatrix)
 {
-       unsigned int i, j, total;
+       unsigned int i, j, k;
        channel_t *ch, *combine;
        matrix4x4_t basematrix, rotatematrix;
 
@@ -1599,11 +1819,14 @@ void S_Update(const matrix4x4_t *listenermatrix)
        combine = NULL;
 
        // 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);
@@ -1641,29 +1864,18 @@ void S_Update(const matrix4x4_t *listenermatrix)
                                }
                        }
                }
+               for (k = 0;k < SND_LISTENERS;k++)
+                       if (ch->listener_volume[k])
+                               break;
+               if (k < SND_LISTENERS)
+                       cls.soundstats.mixedsounds++;
        }
 
        sound_spatialized = true;
 
        // debugging output
        if (snd_show.integer)
-       {
-               total = 0;
-               ch = channels;
-               for (i=0 ; i<total_channels; i++, ch++)
-               {
-                       if (ch->sfx)
-                       {
-                               for (j = 0;j < SND_LISTENERS;j++)
-                                       if (ch->listener_volume[j])
-                                               break;
-                               if (j < SND_LISTENERS)
-                                       total++;
-                       }
-               }
-
-               Con_Printf("----(%u)----\n", total);
-       }
+               Con_Printf("----(%u)----\n", cls.soundstats.mixedsounds);
 
        S_PaintAndSubmit();
 }