diff -ur chocolate-doom-3.0.1/src/i_sdlsound.c chocolate-doom-3.0.1-resamp/src/i_sdlsound.c
--- chocolate-doom-3.0.1/src/i_sdlsound.c	2020-04-04 15:49:05.000000000 -0400
+++ chocolate-doom-3.0.1-resamp/src/i_sdlsound.c	2022-06-05 16:58:38.829477391 -0400
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include <math.h>
 #include "SDL.h"
 #include "SDL_mixer.h"
 
@@ -64,10 +65,6 @@
 static Uint16 mixer_format;
 static int mixer_channels;
 static boolean use_sfx_prefix;
-static boolean (*ExpandSoundData)(sfxinfo_t *sfxinfo,
-                                  byte *data,
-                                  int samplerate,
-                                  int length) = NULL;
 
 // Doubly-linked list of allocated sounds.
 // When a sound is played, it is moved to the head, so that the oldest
@@ -79,14 +76,6 @@
 
 int use_libsamplerate = 0;
 
-// Scale factor used when converting libsamplerate floating point numbers
-// to integers. Too high means the sounds can clip; too low means they
-// will be too quiet. This is an amount that should avoid clipping most
-// of the time: with all the Doom IWAD sound effects, at least. If a PWAD
-// is used, clipping might occur.
-
-float libsamplerate_scale = 0.65f;
-
 // Hook a sound into the linked list at the head.
 
 static void AllocatedSoundLink(allocated_sound_t *snd)
@@ -142,83 +131,20 @@
     free(snd);
 }
 
-// Search from the tail backwards along the allocated sounds list, find
-// and free a sound that is not in use, to free up memory.  Return true
-// for success.
-
-static boolean FindAndFreeSound(void)
-{
-    allocated_sound_t *snd;
-
-    snd = allocated_sounds_tail;
-
-    while (snd != NULL)
-    {
-        if (snd->use_count == 0)
-        {
-            FreeAllocatedSound(snd);
-            return true;
-        }
-
-        snd = snd->prev;
-    }
-
-    // No available sounds to free...
-
-    return false;
-}
-
-// Enforce SFX cache size limit.  We are just about to allocate "len"
-// bytes on the heap for a new sound effect, so free up some space
-// so that we keep allocated_sounds_size < snd_cachesize
-
-static void ReserveCacheSpace(size_t len)
-{
-    if (snd_cachesize <= 0)
-    {
-        return;
-    }
-
-    // Keep freeing sound effects that aren't currently being played,
-    // until there is enough space for the new sound.
-
-    while (allocated_sounds_size + len > snd_cachesize)
-    {
-        // Free a sound.  If there is nothing more to free, stop.
-
-        if (!FindAndFreeSound())
-        {
-            break;
-        }
-    }
-}
-
 // Allocate a block for a new sound effect.
 
 static allocated_sound_t *AllocateSound(sfxinfo_t *sfxinfo, size_t len)
 {
     allocated_sound_t *snd;
 
-    // Keep allocated sounds within the cache size.
-
-    ReserveCacheSpace(len);
-
     // Allocate the sound structure and data.  The data will immediately
     // follow the structure, which acts as a header.
 
-    do
+    snd = malloc(sizeof(allocated_sound_t) + len);
+    if (snd == NULL)
     {
-        snd = malloc(sizeof(allocated_sound_t) + len);
-
-        // Out of memory?  Try to free an old sound, then loop round
-        // and try again.
-
-        if (snd == NULL && !FindAndFreeSound())
-        {
-            return NULL;
-        }
-
-    } while (snd == NULL);
+        return NULL;
+    }
 
     // Skip past the chunk structure for the audio buffer
 
@@ -335,7 +261,7 @@
 
 // When a sound stops, check if it is still playing.  If it is not,
 // we can mark the sound data as CACHE to be freed back for other
-// means.
+// means.  [No longer relevant]
 
 static void ReleaseSoundOnChannel(int channel)
 {
@@ -389,127 +315,6 @@
     }
 }
 
-// libsamplerate-based generic sound expansion function for any sample rate
-//   unsigned 8 bits --> signed 16 bits
-//   mono --> stereo
-//   samplerate --> mixer_freq
-// Returns number of clipped samples.
-// DWF 2008-02-10 with cleanups by Simon Howard.
-
-static boolean ExpandSoundData_SRC(sfxinfo_t *sfxinfo,
-                                   byte *data,
-                                   int samplerate,
-                                   int length)
-{
-    SRC_DATA src_data;
-    float *data_in;
-    uint32_t i, abuf_index=0, clipped=0;
-//    uint32_t alen;
-    int retn;
-    int16_t *expanded;
-    allocated_sound_t *snd;
-    Mix_Chunk *chunk;
-
-    src_data.input_frames = length;
-    data_in = malloc(length * sizeof(float));
-    src_data.data_in = data_in;
-    src_data.src_ratio = (double)mixer_freq / samplerate;
-
-    // We include some extra space here in case of rounding-up.
-    src_data.output_frames = src_data.src_ratio * length + (mixer_freq / 4);
-    src_data.data_out = malloc(src_data.output_frames * sizeof(float));
-
-    assert(src_data.data_in != NULL && src_data.data_out != NULL);
-
-    // Convert input data to floats
-
-    for (i=0; i<length; ++i)
-    {
-        // Unclear whether 128 should be interpreted as "zero" or whether a
-        // symmetrical range should be assumed.  The following assumes a
-        // symmetrical range.
-        data_in[i] = data[i] / 127.5 - 1;
-    }
-
-    // Do the sound conversion
-
-    retn = src_simple(&src_data, SRC_ConversionMode(), 1);
-    assert(retn == 0);
-
-    // Allocate the new chunk.
-
-//    alen = src_data.output_frames_gen * 4;
-
-    snd = AllocateSound(sfxinfo, src_data.output_frames_gen * 4);
-
-    if (snd == NULL)
-    {
-        return false;
-    }
-
-    chunk = &snd->chunk;
-    expanded = (int16_t *) chunk->abuf;
-
-    // Convert the result back into 16-bit integers.
-
-    for (i=0; i<src_data.output_frames_gen; ++i)
-    {
-        // libsamplerate does not limit itself to the -1.0 .. 1.0 range on
-        // output, so a multiplier less than INT16_MAX (32767) is required
-        // to avoid overflows or clipping.  However, the smaller the
-        // multiplier, the quieter the sound effects get, and the more you
-        // have to turn down the music to keep it in balance.
-
-        // 22265 is the largest multiplier that can be used to resample all
-        // of the Vanilla DOOM sound effects to 48 kHz without clipping
-        // using SRC_SINC_BEST_QUALITY.  It is close enough (only slightly
-        // too conservative) for SRC_SINC_MEDIUM_QUALITY and
-        // SRC_SINC_FASTEST.  PWADs with interestingly different sound
-        // effects or target rates other than 48 kHz might still result in
-        // clipping--I don't know if there's a limit to it.
-
-        // As the number of clipped samples increases, the signal is
-        // gradually overtaken by noise, with the loudest parts going first.
-        // However, a moderate amount of clipping is often tolerated in the
-        // quest for the loudest possible sound overall.  The results of
-        // using INT16_MAX as the multiplier are not all that bad, but
-        // artifacts are noticeable during the loudest parts.
-
-        float cvtval_f =
-            src_data.data_out[i] * libsamplerate_scale * INT16_MAX;
-        int32_t cvtval_i = cvtval_f + (cvtval_f < 0 ? -0.5 : 0.5);
-
-        // Asymmetrical sound worries me, so we won't use -32768.
-        if (cvtval_i < -INT16_MAX)
-        {
-            cvtval_i = -INT16_MAX;
-            ++clipped;
-        }
-        else if (cvtval_i > INT16_MAX)
-        {
-            cvtval_i = INT16_MAX;
-            ++clipped;
-        }
-
-        // Left and right channels
-
-        expanded[abuf_index++] = cvtval_i;
-        expanded[abuf_index++] = cvtval_i;
-    }
-
-    free(data_in);
-    free(src_data.data_out);
-
-    if (clipped > 0)
-    {
-        fprintf(stderr, "Sound '%s': clipped %u samples (%0.2f %%)\n", 
-                        sfxinfo->name, clipped,
-                        400.0 * clipped / chunk->alen);
-    }
-
-    return true;
-}
-
 #endif
 
 static boolean ConvertibleRatio(int freq1, int freq2)
@@ -592,12 +397,11 @@
 #endif
 
 // Generic sound expansion function for any sample rate.
-// Returns number of clipped samples (always 0).
 
-static boolean ExpandSoundData_SDL(sfxinfo_t *sfxinfo,
-                                   byte *data,
-                                   int samplerate,
-                                   int length)
+static boolean ExpandSoundData(sfxinfo_t *sfxinfo,
+                               byte *data,
+                               int samplerate,
+                               int length)
 {
     SDL_AudioCVT convertor;
     allocated_sound_t *snd;
@@ -708,40 +512,47 @@
     return true;
 }
 
-// Load and convert a sound effect
-// Returns true if successful
-
-static boolean CacheSFX(sfxinfo_t *sfxinfo)
+// Load and validate a sound effect lump.
+// Postconditions if sound is valid:
+//     returns true
+//     starred parameters are set, with data_ref pointing to start of sound
+//     caller is responsible for releasing the identified lump
+// Postconditions if sound is invalid:
+//     returns false
+//     starred parameters are garbage
+//     lump already released
+
+static boolean LoadSoundLump(int lumpnum,
+			     int *samplerate,
+			     uint32_t *length,
+			     byte **data_ref)
 {
-    int lumpnum;
-    unsigned int lumplen;
-    int samplerate;
-    unsigned int length;
+    int lumplen;
     byte *data;
 
-    // need to load the sound
+    // Load the sound
 
-    lumpnum = sfxinfo->lumpnum;
-    data = W_CacheLumpNum(lumpnum, PU_STATIC);
+    *data_ref   = W_CacheLumpNum(lumpnum, PU_STATIC);
     lumplen = W_LumpLength(lumpnum);
+    data  = *data_ref;
 
-    // Check the header, and ensure this is a valid sound
+    // Ensure this is a valid sound
 
-    if (lumplen < 8
-     || data[0] != 0x03 || data[1] != 0x00)
+    if (lumplen < 8 || data[0] != 0x03 || data[1] != 0x00)
     {
-        // Invalid sound
-
-        return false;
+	// Invalid sound
+	W_ReleaseLumpNum(lumpnum);
+	return false;
     }
 
     // 16 bit sample rate field, 32 bit length field
 
-    samplerate = (data[3] << 8) | data[2];
-    length = (data[7] << 24) | (data[6] << 16) | (data[5] << 8) | data[4];
+    *samplerate = (data[3] << 8) | data[2];
+    *length = (data[7] << 24) | (data[6] << 16) | (data[5] << 8) | data[4];
 
-    // If the header specifies that the length of the sound is greater than
-    // the length of the lump itself, this is an invalid sound lump
+    // If the header specifies that the length of the sound is
+    // greater than the length of the lump itself, this is an invalid
+    // sound lump.
 
     // We also discard sound lumps that are less than 49 samples long,
     // as this is how DMX behaves - although the actual cut-off length
@@ -749,20 +560,42 @@
     // further investigation to better understand the correct
     // behavior.
 
-    if (length > lumplen - 8 || length <= 48)
+    if (*length > lumplen - 8 || *length <= 48)
     {
-        return false;
+	W_ReleaseLumpNum(lumpnum);
+	return false;
     }
 
+    // Prune header
+    *data_ref += 8;
+
     // The DMX sound library seems to skip the first 16 and last 16
     // bytes of the lump - reason unknown.
 
-    data += 16;
-    length -= 32;
+    *data_ref += 16;
+    *length -= 32;
 
-    // Sample rate conversion
+    return true;
+}
+
+// Load and convert a sound effect
+// Returns true if successful
+
+static boolean CacheSFX(sfxinfo_t *sfxinfo)
+{
+    int samplerate;
+    unsigned int length;
+    byte *data;
+
+#ifdef HAVE_LIBSAMPLERATE
+    assert(!use_libsamplerate); // Pre-cache or die
+#endif
 
-    if (!ExpandSoundData(sfxinfo, data + 8, samplerate, length))
+    if (!LoadSoundLump(sfxinfo->lumpnum, &samplerate, &length, &data))
+        return false;
+
+    // Sample rate conversion
+    if (!ExpandSoundData(sfxinfo, data, samplerate, length))
     {
         return false;
     }
@@ -780,9 +613,7 @@
 #endif
 
     // don't need the original lump any more
-  
-    W_ReleaseLumpNum(lumpnum);
-
+    W_ReleaseLumpNum(sfxinfo->lumpnum);
     return true;
 }
 
@@ -815,7 +646,12 @@
 static void I_SDL_PrecacheSounds(sfxinfo_t *sounds, int num_sounds)
 {
     char namebuf[9];
-    int i;
+    uint32_t sound_i, sample_i;
+    boolean good_sound[num_sounds];
+    float *resampled_sound[num_sounds];
+    uint32_t resampled_sound_length[num_sounds];
+    float norm_factor;
+    float max_amp = 0;
 
     // Don't need to precache the sounds unless we are using libsamplerate.
 
@@ -824,27 +660,121 @@
 	return;
     }
 
-    printf("I_SDL_PrecacheSounds: Precaching all sound effects..");
-
-    for (i=0; i<num_sounds; ++i)
-    {
-        if ((i % 6) == 0)
-        {
-            printf(".");
-            fflush(stdout);
-        }
+    printf("I_SDL_PrecacheSounds: Resampling all sound effects to %d Hz..", mixer_freq);
 
-        GetSfxLumpName(&sounds[i], namebuf, sizeof(namebuf));
+    // Pass 1:  resample all sounds and determine maximum amplitude.
 
-        sounds[i].lumpnum = W_CheckNumForName(namebuf);
+    for (sound_i=0; sound_i<num_sounds; ++sound_i)
+    {
+	good_sound[sound_i] = false;
 
-        if (sounds[i].lumpnum != -1)
-        {
-            CacheSFX(&sounds[i]);
-        }
+	if ((sound_i % 6) == 0)
+	{
+	    printf(".");
+	    fflush(stdout);
+	}
+
+        GetSfxLumpName(&sounds[sound_i], namebuf, sizeof(namebuf));
+	sounds[sound_i].lumpnum = W_CheckNumForName(namebuf);
+	if (sounds[sound_i].lumpnum != -1)
+	{
+	    // 2022-06-05  src_data.data_in acquired a const qualifier at some
+	    // point, which caused unnecessary FTB in this block.
+	    int samplerate;
+	    uint32_t length;
+	    byte *data;
+	    double of_temp;
+	    int retn;
+	    float *rsound, *data_in_nonconst;
+	    uint32_t rlen;
+	    SRC_DATA src_data;
+
+	    if (!LoadSoundLump(sounds[sound_i].lumpnum, &samplerate, &length, &data))
+		continue;
+
+	    assert(length <= LONG_MAX);
+	    src_data.input_frames = length;
+	    data_in_nonconst = malloc(length * sizeof(float));
+	    src_data.src_ratio = (double)mixer_freq / samplerate;
+
+	    // mixer_freq / 4 adds a quarter-second safety margin.
+	    of_temp = src_data.src_ratio * length + (mixer_freq / 4);
+	    assert(of_temp <= LONG_MAX);
+	    src_data.output_frames = of_temp;
+	    src_data.data_out = malloc(src_data.output_frames * sizeof(float));
+	    assert(data_in_nonconst != NULL && src_data.data_out != NULL);
+
+	    // Convert input data to floats
+	    for (sample_i=0; sample_i<length; ++sample_i)
+	    {
+		// Unclear whether 128 should be interpreted as "zero" or
+		// whether a symmetrical range should be assumed.  The
+		// following assumes a symmetrical range.
+		data_in_nonconst[sample_i] = data[sample_i] / 127.5 - 1;
+	    }
+	    src_data.data_in = data_in_nonconst;
+
+	    // don't need the original lump any more
+	    W_ReleaseLumpNum(sounds[sound_i].lumpnum);
+
+	    // Resample
+	    retn = src_simple(&src_data, SRC_ConversionMode(), 1);
+	    assert(retn == 0);
+	    assert(src_data.output_frames_gen > 0);
+	    resampled_sound[sound_i] = src_data.data_out;
+	    resampled_sound_length[sound_i] = src_data.output_frames_gen;
+	    free(data_in_nonconst);
+	    good_sound[sound_i] = true;
+
+	    // Track maximum amplitude for later normalization
+	    rsound = resampled_sound[sound_i];
+	    rlen = resampled_sound_length[sound_i];
+	    for (sample_i=0; sample_i<rlen; ++sample_i)
+	    {
+		float fabs_amp = fabsf(rsound[sample_i]);
+		if (fabs_amp > max_amp)
+		    max_amp = fabs_amp;
+	    }
+	}
+    }
+
+    // Pass 2:  normalize and convert to signed 16-bit stereo.
+
+    if (max_amp <= 0)
+	max_amp = 1;
+    norm_factor = INT16_MAX / max_amp;
+
+    for (sound_i=0; sound_i<num_sounds; ++sound_i)
+    {
+	if (good_sound[sound_i])
+	{
+	    uint32_t rlen = resampled_sound_length[sound_i];
+	    int16_t *expanded;
+	    uint32_t abuf_index;
+	    float *rsound;
+	    Mix_Chunk *chunk;
+	    allocated_sound_t *snd;
+
+	    snd = AllocateSound(&sounds[sound_i], rlen * 4);
+	    assert (snd);
+	    chunk = &snd->chunk;
+	    expanded = (int16_t *) chunk->abuf;
+	    abuf_index=0;
+	    rsound = resampled_sound[sound_i];
+	    for (sample_i=0; sample_i<rlen; ++sample_i)
+	    {
+		float   cvtval_f = norm_factor * rsound[sample_i];
+		int16_t cvtval_i = cvtval_f + (cvtval_f < 0 ? -0.5 : 0.5);
+
+		// Left and right channels
+		expanded[abuf_index++] = cvtval_i;
+		expanded[abuf_index++] = cvtval_i;
+	    }
+	    free(rsound);
+	}
     }
 
-    printf("\n");
+    printf(" scale = %0.2f\n", norm_factor/INT16_MAX);
 }
 
 #else
@@ -1107,8 +1037,6 @@
         return false;
     }
 
-    ExpandSoundData = ExpandSoundData_SDL;
-
     Mix_QuerySpec(&mixer_freq, &mixer_format, &mixer_channels);
 
 #ifdef HAVE_LIBSAMPLERATE
@@ -1119,8 +1047,6 @@
             I_Error("I_SDL_InitSound: Invalid value for use_libsamplerate: %i",
                     use_libsamplerate);
         }
-
-        ExpandSoundData = ExpandSoundData_SRC;
     }
 #else
     if (use_libsamplerate != 0)
diff -ur chocolate-doom-3.0.1/src/i_sound.c chocolate-doom-3.0.1-resamp/src/i_sound.c
--- chocolate-doom-3.0.1/src/i_sound.c	2020-06-24 23:10:06.000000000 -0400
+++ chocolate-doom-3.0.1-resamp/src/i_sound.c	2022-06-05 17:08:37.929479592 -0400
@@ -33,11 +33,6 @@
 
 int snd_samplerate = 44100;
 
-// Maximum number of bytes to dedicate to allocated sound effects.
-// (Default: 64MB)
-
-int snd_cachesize = 64 * 1024 * 1024;
-
 // Config variable that controls the sound buffer size.
 // We default to 28ms (1000 / 35fps = 1 buffer per tic).
 
@@ -435,7 +430,6 @@
 {
     extern char *snd_dmxoption;
     extern int use_libsamplerate;
-    extern float libsamplerate_scale;
 
     M_BindIntVariable("snd_musicdevice",         &snd_musicdevice);
     M_BindIntVariable("snd_sfxdevice",           &snd_sfxdevice);
@@ -447,7 +441,6 @@
     M_BindStringVariable("snd_musiccmd",         &snd_musiccmd);
     M_BindStringVariable("snd_dmxoption",        &snd_dmxoption);
     M_BindIntVariable("snd_samplerate",          &snd_samplerate);
-    M_BindIntVariable("snd_cachesize",           &snd_cachesize);
     M_BindIntVariable("opl_io_port",             &opl_io_port);
     M_BindIntVariable("snd_pitchshift",          &snd_pitchshift);
 
@@ -457,6 +450,5 @@
     M_BindIntVariable("gus_ram_kb",              &gus_ram_kb);
 
     M_BindIntVariable("use_libsamplerate",       &use_libsamplerate);
-    M_BindFloatVariable("libsamplerate_scale",   &libsamplerate_scale);
 }
 
diff -ur chocolate-doom-3.0.1/src/i_sound.h chocolate-doom-3.0.1-resamp/src/i_sound.h
--- chocolate-doom-3.0.1/src/i_sound.h	2020-06-24 23:10:06.000000000 -0400
+++ chocolate-doom-3.0.1-resamp/src/i_sound.h	2022-06-05 17:08:37.929479592 -0400
@@ -230,7 +230,6 @@
 extern int snd_sfxdevice;
 extern int snd_musicdevice;
 extern int snd_samplerate;
-extern int snd_cachesize;
 extern int snd_maxslicetime_ms;
 extern char *snd_musiccmd;
 extern int snd_pitchshift;
diff -ur chocolate-doom-3.0.1/src/m_config.c chocolate-doom-3.0.1-resamp/src/m_config.c
--- chocolate-doom-3.0.1/src/m_config.c	2020-06-24 23:10:06.000000000 -0400
+++ chocolate-doom-3.0.1-resamp/src/m_config.c	2022-06-05 17:08:37.929479592 -0400
@@ -833,13 +833,6 @@
     CONFIG_VARIABLE_INT(snd_samplerate),
 
     //!
-    // Maximum number of bytes to allocate for caching converted sound
-    // effects in memory. If set to zero, there is no limit applied.
-    //
-
-    CONFIG_VARIABLE_INT(snd_cachesize),
-
-    //!
     // Maximum size of the output sound buffer size in milliseconds.
     // Sound output is generated periodically in slices. Higher values
     // might be more efficient but will introduce latency to the
@@ -897,18 +890,6 @@
     CONFIG_VARIABLE_INT(use_libsamplerate),
 
     //!
-    // Scaling factor used by libsamplerate. This is used when converting
-    // sounds internally back into integer form; normally it should not
-    // be necessary to change it from the default value. The only time
-    // it might be needed is if a PWAD file is loaded that contains very
-    // loud sounds, in which case the conversion may cause sound clipping
-    // and the scale factor should be reduced. The lower the value, the
-    // quieter the sound effects become, so it should be set as high as is
-    // possible without clipping occurring.
-
-    CONFIG_VARIABLE_FLOAT(libsamplerate_scale),
-
-    //!
     // Full path to a directory containing configuration files for
     // substitute music packs. These packs contain high quality renderings
     // of game music to be played instead of using the system's built-in
diff -ur chocolate-doom-3.0.1/src/setup/sound.c chocolate-doom-3.0.1-resamp/src/setup/sound.c
--- chocolate-doom-3.0.1/src/setup/sound.c	2020-06-24 23:10:06.000000000 -0400
+++ chocolate-doom-3.0.1-resamp/src/setup/sound.c	2022-06-05 17:08:37.929479592 -0400
@@ -48,7 +48,6 @@
 int snd_musicdevice = SNDDEVICE_SB;
 int snd_samplerate = 44100;
 int opl_io_port = 0x388;
-int snd_cachesize = 64 * 1024 * 1024;
 int snd_maxslicetime_ms = 28;
 char *snd_musiccmd = "";
 int snd_pitchshift = 0;
@@ -60,7 +59,6 @@
 static int voiceVolume = 15;
 static int show_talk = 0;
 static int use_libsamplerate = 0;
-static float libsamplerate_scale = 0.65;
 
 static char *music_pack_path = NULL;
 static char *timidity_cfg_path = NULL;
@@ -202,7 +200,6 @@
     M_BindIntVariable("music_volume",             &musicVolume);
 
     M_BindIntVariable("use_libsamplerate",        &use_libsamplerate);
-    M_BindFloatVariable("libsamplerate_scale",    &libsamplerate_scale);
 
     M_BindIntVariable("gus_ram_kb",               &gus_ram_kb);
     M_BindStringVariable("gus_patch_path",        &gus_patch_path);
@@ -217,7 +214,6 @@
     M_BindStringVariable("snd_musiccmd",          &snd_musiccmd);
     M_BindStringVariable("snd_dmxoption",         &snd_dmxoption);
 
-    M_BindIntVariable("snd_cachesize",            &snd_cachesize);
     M_BindIntVariable("opl_io_port",              &opl_io_port);
 
     M_BindIntVariable("snd_pitchshift",           &snd_pitchshift);