Index: code/sound/openal.cpp
===================================================================
--- code/sound/openal.cpp    (revision 8970)
+++ code/sound/openal.cpp    (working copy)
@@ -197,19 +197,21 @@ static void find_playback_device()
 		// check how many sources we can create
 		static const int MIN_SOURCES = 48;	// MAX_CHANNELS + 16 spare
 		int si = 0;
+		ALuint source_id[MIN_SOURCES] = {0};
 
-		for (si = 0; si < MIN_SOURCES; si++) {
-			ALuint source_id = 0;
-			alGenSources(1, &source_id);
+		for (si = 1; si <= MIN_SOURCES; si++) {
+			alGenSources(si, &source_id[0]);
 
-			if (alGetError() != AL_NO_ERROR) {
+			const char *error_text = openal_error_string(0);
+			if ( error_text != NULL ) {
+				mprintf(("OpenAL error \"%s\" when creating %i sources with device: %s\n",error_text,si,pdev->device_name.c_str()));
 				break;
 			}
 
-			alDeleteSources(1, &source_id);
+			alDeleteSources(si, &source_id[0]);
 		}
 
-		if (si == MIN_SOURCES) {
+		if (si == MIN_SOURCES+1) {
 			// ok, it supports our minimum requirements
 			pdev->usable = true;
 

Actually do as the comment says and don't play the sound

Our fancy OpenAL implemenation needs to be as harsh to the engine as
the original sound code and just deny the request just like the old
sound code implemenation would.  Otherwise all of the fine tuning that
:v: did is thrown out and the engine just trips over itself.
Index: code/sound/ds.cpp
===================================================================
--- code/sound/ds.cpp	(revision 8846)
+++ code/sound/ds.cpp	(working copy)
@@ -1408,34 +1408,37 @@
 		}
 	}
 
-	// Make sure that we are not going to play more copies of this sound than we should be
-	if ( Cmdline_enforce_concurrent_sound_count && (instance_count >= limit) && (lowest_instance_vol_index >= 0) ) {
+	// If we've exceeded the limit, then maybe stop the duplicate if it is lower volume
+	if ( (instance_count >= limit) && (lowest_instance_vol_index >= 0) ) {
 		// If there is a lower volume duplicate, stop it.... otherwise, don't play the sound
 		if (lowest_instance_vol <= new_volume) {
 			ds_close_channel_fast(lowest_instance_vol_index);
 			first_free_channel = lowest_instance_vol_index;
+		} else {
+			// NOTE: yes we are preventing the sound from playing even if
+			// there is an available channel because we are over the limit
+			// requested by the rest of the engine, which means if we do
+			// not honour its request to limit the count then the engine
+			// will trip itself up by using all channels without having
+			// the intention of actually doing so.  This means we get
+			// very loud sounds, missing more important sounds, etc.
+			// Effectivly the problem is the rest of the engine assumes
+			// it is still stuck in the 90s with a sound card that only has
+			// <=16 channels so we need to give it a sound card that
+			// has 16 channels (though we are actually allowing 32 channels
+			// just because we can).
+			first_free_channel = -1;
 		}
-	}
-
-	if (first_free_channel < 0) {
-		// If we've exceeded the limit, then maybe stop the duplicate if it is lower volume
-		if ( (instance_count >= limit) && (lowest_instance_vol_index >= 0) ) {
-			// If there is a lower volume duplicate, stop it.... otherwise, don't play the sound
-			if (lowest_instance_vol <= new_volume) {
-				ds_close_channel_fast(lowest_instance_vol_index);
-				first_free_channel = lowest_instance_vol_index;
+	} else {
+		// there is no limit barrier to play the sound, so see if we've ran out of channels
+		// stop the lowest volume instance to play our sound if priority demands it
+		if ( (lowest_vol_index != -1) && (priority == DS_MUST_PLAY) ) {
+			// Check if the lowest volume playing is less than the volume of the requested sound.
+			// If so, then we are going to trash the lowest volume sound.
+			if ( Channels[lowest_vol_index].vol <= new_volume ) {
+				ds_close_channel_fast(lowest_vol_index);
+				first_free_channel = lowest_vol_index;
 			}
-		} else {
-			// there is no limit barrier to play the sound, so see if we've ran out of channels
-			// stop the lowest volume instance to play our sound if priority demands it
-			if ( (lowest_vol_index != -1) && (priority == DS_MUST_PLAY) ) {
-				// Check if the lowest volume playing is less than the volume of the requested sound.
-				// If so, then we are going to trash the lowest volume sound.
-				if ( Channels[lowest_vol_index].vol <= new_volume ) {
-					ds_close_channel_fast(lowest_vol_index);
-					first_free_channel = lowest_vol_index;
-				}
-			}
 		}
 	}
 

Index: code/sound/ds.cpp
===================================================================
--- code/sound/ds.cpp	(revision 8916)
+++ code/sound/ds.cpp	(working copy)
@@ -1402,24 +1402,36 @@
 		}
 	}
 
-	if (first_free_channel < 0) {
-		// If we've exceeded the limit, then maybe stop the duplicate if it is lower volume
-		if ( (instance_count >= limit) && (lowest_instance_vol_index >= 0) ) {
-			// If there is a lower volume duplicate, stop it.... otherwise, don't play the sound
-			if (lowest_instance_vol <= new_volume) {
-				ds_close_channel_fast(lowest_instance_vol_index);
-				first_free_channel = lowest_instance_vol_index;
-			}
+	// If we've exceeded the limit, then maybe stop the duplicate if it is lower volume
+	if ( (instance_count >= limit) && (lowest_instance_vol_index >= 0) ) {
+		// If there is a lower volume duplicate, stop it.... otherwise, don't play the sound
+		if (lowest_instance_vol <= new_volume) {
+			ds_close_channel_fast(lowest_instance_vol_index);
+			first_free_channel = lowest_instance_vol_index;
 		} else {
-			// there is no limit barrier to play the sound, so see if we've ran out of channels
-			// stop the lowest volume instance to play our sound if priority demands it
-			if ( (lowest_vol_index != -1) && (priority == DS_MUST_PLAY) ) {
-				// Check if the lowest volume playing is less than the volume of the requested sound.
-				// If so, then we are going to trash the lowest volume sound.
-				if ( Channels[lowest_vol_index].vol <= new_volume ) {
-					ds_close_channel_fast(lowest_vol_index);
-					first_free_channel = lowest_vol_index;
-				}
+			// NOTE: yes we are preventing the sound from playing even if
+			// there is an available channel because we are over the limit
+			// requested by the rest of the engine, which means if we do
+			// not honour its request to limit the count then the engine
+			// will trip itself up by using all channels without having
+			// the intention of actually doing so.  This means we get
+			// very loud sounds, missing more important sounds, etc.
+			// Effectivly the problem is the rest of the engine assumes
+			// it is still stuck in the 90s with a sound card that only has
+			// <=16 channels so we need to give it a sound card that
+			// has 16 channels (though we are actually allowing 32 channels
+			// just because we can).
+			first_free_channel = -1;
+		}
+	} else {
+		// there is no limit barrier to play the sound, so see if we've ran out of channels
+		// stop the lowest volume instance to play our sound if priority demands it
+		if ( (lowest_vol_index != -1) && (priority == DS_MUST_PLAY) ) {
+			// Check if the lowest volume playing is less than the volume of the requested sound.
+			// If so, then we are going to trash the lowest volume sound.
+			if ( Channels[lowest_vol_index].vol <= new_volume ) {
+				ds_close_channel_fast(lowest_vol_index);
+				first_free_channel = lowest_vol_index;
 			}
 		}
 	}

Index: code/sound/ds.cpp
===================================================================
--- code/sound/ds.cpp	(revision 9076)
+++ code/sound/ds.cpp	(working copy)
@@ -1401,6 +1401,8 @@
 					lowest_instance_vol = chp->vol;
 					lowest_instance_vol_index = i;
 				}
+			} else if ( chp->is_voice_msg ) {
+				// a playing voice message is not allowed to be preempted
 			} else if ( (chp->vol < lowest_vol) && (chp->looping == FALSE) ) {
 				lowest_vol_index = i;
 				lowest_vol = chp->vol;
@@ -1429,9 +1431,10 @@
 			// just because we can).
 			first_free_channel = -1;
 		}
-	} else {
-		// there is no limit barrier to play the sound, so see if we've ran out of channels
-		// stop the lowest volume instance to play our sound if priority demands it
+	} else if (first_free_channel == -1) {
+		// there is no limit barrier to play the sound, but we have run out
+		// of channels so stop the lowest volume instance to play our sound
+		// if priority demands it
 		if ( (lowest_vol_index != -1) && (priority == DS_MUST_PLAY) ) {
 			// Check if the lowest volume playing is less than the volume of the requested sound.
 			// If so, then we are going to trash the lowest volume sound.