ref: df292a6dce27e7b20faa0c829aa0c58a3693f979
dir: /src/i_sdlsound.c/
// Emacs style mode select -*- C++ -*- //----------------------------------------------------------------------------- // // Copyright(C) 1993-1996 Id Software, Inc. // Copyright(C) 2005 Simon Howard // Copyright(C) 2008 David Flater // // 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 the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA // 02111-1307, USA. // // DESCRIPTION: // System interface for sound. // //----------------------------------------------------------------------------- #include "config.h" #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <math.h> #include "SDL.h" #include "SDL_mixer.h" #ifdef HAVE_LIBSAMPLERATE #include <samplerate.h> #endif #include "deh_main.h" #include "i_system.h" #include "i_swap.h" #include "s_sound.h" #include "m_argv.h" #include "w_wad.h" #include "z_zone.h" #include "doomdef.h" #define LOW_PASS_FILTER //#define DEBUG_DUMP_WAVS #define MAX_SOUND_SLICE_TIME 70 /* ms */ #define NUM_CHANNELS 16 static boolean setpanning_workaround = false; static boolean sound_initialized = false; static Mix_Chunk sound_chunks[NUMSFX]; static int channels_playing[NUM_CHANNELS]; static int mixer_freq; static Uint16 mixer_format; static int mixer_channels; int use_libsamplerate = 0; // 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. static void ReleaseSoundOnChannel(int channel) { int i; int id = channels_playing[channel]; if (!id) { return; } channels_playing[channel] = sfx_None; #ifdef HAVE_LIBSAMPLERATE // Don't allow precached sounds to be swapped out. if (use_libsamplerate) return; #endif for (i=0; i<NUM_CHANNELS; ++i) { // Playing on this channel? if so, don't release. if (channels_playing[i] == id) return; } // Not used on any channel, and can be safely released Z_ChangeTag(sound_chunks[id].abuf, PU_CACHE); } #ifdef HAVE_LIBSAMPLERATE // Returns the conversion mode for libsamplerate to use. static int SRC_ConversionMode(void) { switch (use_libsamplerate) { // 0 = disabled default: case 0: return -1; // Ascending numbers give higher quality case 1: return SRC_LINEAR; case 2: return SRC_ZERO_ORDER_HOLD; case 3: return SRC_SINC_FASTEST; case 4: return SRC_SINC_MEDIUM_QUALITY; case 5: return SRC_SINC_BEST_QUALITY; } } #endif static boolean ConvertibleRatio(int freq1, int freq2) { int ratio; if (freq1 > freq2) { return ConvertibleRatio(freq2, freq1); } else if ((freq2 % freq1) != 0) { // Not in a direct ratio return false; } else { // Check the ratio is a power of 2 ratio = freq2 / freq1; while ((ratio & 1) == 0) { ratio = ratio >> 1; } return ratio == 1; } } #ifdef DEBUG_DUMP_WAVS // Debug code to dump resampled sound effects to WAV files for analysis. static void WriteWAV(char *filename, byte *data, uint32_t length, int samplerate) { FILE *wav; unsigned int i; unsigned short s; wav = fopen(filename, "wb"); // Header fwrite("RIFF", 1, 4, wav); i = LONG(36 + samplerate); fwrite(&i, 4, 1, wav); fwrite("WAVE", 1, 4, wav); // Subchunk 1 fwrite("fmt ", 1, 4, wav); i = LONG(16); fwrite(&i, 4, 1, wav); // Length s = SHORT(1); fwrite(&s, 2, 1, wav); // Format (PCM) s = SHORT(2); fwrite(&s, 2, 1, wav); // Channels (2=stereo) i = LONG(samplerate); fwrite(&i, 4, 1, wav); // Sample rate i = LONG(samplerate * 2 * 2); fwrite(&i, 4, 1, wav); // Byte rate (samplerate * stereo * 16 bit) s = SHORT(2 * 2); fwrite(&s, 2, 1, wav); // Block align (stereo * 16 bit) s = SHORT(16); fwrite(&s, 2, 1, wav); // Bits per sample (16 bit) // Data subchunk fwrite("data", 1, 4, wav); i = LONG(length); fwrite(&i, 4, 1, wav); // Data length fwrite(data, 1, length, wav); // Data fclose(wav); } #endif // Generic sound expansion function for any sample rate. static void ExpandSoundData_SDL(byte *data, int samplerate, uint32_t length, Mix_Chunk *destination) { SDL_AudioCVT convertor; uint32_t expanded_length; // Calculate the length of the expanded version of the sample. expanded_length = (uint32_t) ((((uint64_t) length) * mixer_freq) / samplerate); // Double up twice: 8 -> 16 bit and mono -> stereo expanded_length *= 4; destination->alen = expanded_length; destination->abuf = Z_Malloc(expanded_length, PU_STATIC, &destination->abuf); // If we can, use the standard / optimized SDL conversion routines. if (samplerate <= mixer_freq && ConvertibleRatio(samplerate, mixer_freq) && SDL_BuildAudioCVT(&convertor, AUDIO_U8, 1, samplerate, mixer_format, mixer_channels, mixer_freq)) { convertor.buf = destination->abuf; convertor.len = length; memcpy(convertor.buf, data, length); SDL_ConvertAudio(&convertor); } else { Sint16 *expanded = (Sint16 *) destination->abuf; int expanded_length; int expand_ratio; int i; // Generic expansion if conversion does not work: // // SDL's audio conversion only works for rate conversions that are // powers of 2; if the two formats are not in a direct power of 2 // ratio, do this naive conversion instead. // number of samples in the converted sound expanded_length = ((uint64_t) length * mixer_freq) / samplerate; expand_ratio = (length << 8) / expanded_length; for (i=0; i<expanded_length; ++i) { Sint16 sample; int src; src = (i * expand_ratio) >> 8; sample = data[src] | (data[src] << 8); sample -= 32768; // expand 8->16 bits, mono->stereo expanded[i * 2] = expanded[i * 2 + 1] = sample; } #ifdef LOW_PASS_FILTER // Perform a low-pass filter on the upscaled sound to filter // out high-frequency noise from the conversion process. { float rc, dt, alpha; // Low-pass filter for cutoff frequency f: // // For sampling rate r, dt = 1 / r // rc = 1 / 2*pi*f // alpha = dt / (rc + dt) // Filter to the half sample rate of the original sound effect // (maximum frequency, by nyquist) dt = 1.0f / mixer_freq; rc = 1.0f / (3.14f * samplerate); alpha = dt / (rc + dt); // Both channels are processed in parallel, hence [i-2]: for (i=2; i<expanded_length * 2; ++i) { expanded[i] = (Sint16) (alpha * expanded[i] + (1 - alpha) * expanded[i-2]); } } #endif /* #ifdef LOW_PASS_FILTER */ } } // Load and validate a sound effect lump. // Preconditions: // S_sfx[sound].lumpnum has been set // 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 sound, int *lumpnum, int *samplerate, uint32_t *length, byte **data_ref) { int lumplen; byte *data; // Load the sound *lumpnum = S_sfx[sound].lumpnum; *data_ref = W_CacheLumpNum(*lumpnum, PU_STATIC); lumplen = W_LumpLength(*lumpnum); data = *data_ref; // Ensure this is a valid sound if (lumplen < 8 || data[0] != 0x03 || data[1] != 0x00) { // 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]; // 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 // seems to vary slightly depending on the sample rate. This needs // further investigation to better understand the correct // behavior. if (*length > lumplen - 8 || *length <= 48) { 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_ref += 16; *length -= 32; return true; } // Load and convert a sound effect // Returns true if successful static boolean CacheSFX_SDL(int sound) { int lumpnum; int samplerate; uint32_t length; byte *data; #ifdef HAVE_LIBSAMPLERATE assert(!use_libsamplerate); // Should be using I_PrecacheSounds_SRC instead #endif if (!LoadSoundLump(sound, &lumpnum, &samplerate, &length, &data)) return false; // Sample rate conversion // sound_chunks[sound].alen and abuf are determined by ExpandSoundData. sound_chunks[sound].allocated = 1; sound_chunks[sound].volume = MIX_MAX_VOLUME; ExpandSoundData_SDL(data, samplerate, length, &sound_chunks[sound]); #ifdef DEBUG_DUMP_WAVS { char filename[16]; sprintf(filename, "%s.wav", DEH_String(S_sfx[sound].name)); WriteWAV(filename, sound_chunks[sound].abuf, sound_chunks[sound].alen, mixer_freq); } #endif // don't need the original lump any more W_ReleaseLumpNum(lumpnum); return true; } #ifdef HAVE_LIBSAMPLERATE // Preload and resample all sound effects with libsamplerate. static void I_PrecacheSounds_SRC(void) { char namebuf[9]; uint32_t sound_i, sample_i; boolean good_sound[NUMSFX]; float *resampled_sound[NUMSFX]; uint32_t resampled_sound_length[NUMSFX]; float norm_factor; float max_amp = 0; unsigned int zone_size; assert(use_libsamplerate); zone_size = Z_ZoneSize(); if (zone_size < 32 * 1024 * 1024) { fprintf(stderr, "WARNING: low memory. Heap size is only %d MiB.\n" "WARNING: use_libsamplerate needs more heap!\n" "WARNING: put -mb 64 on the command line to avoid " "\"Error: Z_Malloc: failed on allocation of X bytes\" !\n", zone_size / (1024 * 1024)); } printf("I_PrecacheSounds_SRC: Precaching all sound effects.."); // Pass 1: resample all sounds and determine maximum amplitude. for (sound_i=sfx_pistol; sound_i<NUMSFX; ++sound_i) { good_sound[sound_i] = false; if ((sound_i % 6) == 0) { printf("."); fflush(stdout); } sprintf(namebuf, "ds%s", DEH_String(S_sfx[sound_i].name)); S_sfx[sound_i].lumpnum = W_CheckNumForName(namebuf); if (S_sfx[sound_i].lumpnum != -1) { int lumpnum; int samplerate; uint32_t length; byte *data; double of_temp; int retn; float *rsound; uint32_t rlen; SRC_DATA src_data; if (!LoadSoundLump(sound_i, &lumpnum, &samplerate, &length, &data)) continue; assert(length <= LONG_MAX); src_data.input_frames = length; src_data.data_in = 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(src_data.data_in != 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. src_data.data_in[sample_i] = data[sample_i] / 127.5 - 1; } // don't need the original lump any more W_ReleaseLumpNum(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(src_data.data_in); 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=sfx_pistol; sound_i<NUMSFX; ++sound_i) { if (good_sound[sound_i]) { uint32_t rlen = resampled_sound_length[sound_i]; int16_t *expanded; uint32_t abuf_index; float *rsound; sound_chunks[sound_i].allocated = 1; sound_chunks[sound_i].volume = MIX_MAX_VOLUME; sound_chunks[sound_i].alen = rlen * 4; sound_chunks[sound_i].abuf = Z_Malloc(sound_chunks[sound_i].alen, PU_STATIC, &sound_chunks[sound_i].abuf); expanded = (int16_t *) sound_chunks[sound_i].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(" norm factor = %f\n", norm_factor); } #endif static Mix_Chunk *GetSFXChunk(int sound_id) { if (sound_chunks[sound_id].abuf == NULL) { #ifdef HAVE_LIBSAMPLERATE if (use_libsamplerate != 0) return NULL; /* If valid, it should have been precached */ #endif if (!CacheSFX_SDL(sound_id)) return NULL; } else { // don't free the sound while it is playing! Z_ChangeTag(sound_chunks[sound_id].abuf, PU_STATIC); } return &sound_chunks[sound_id]; } // // Retrieve the raw data lump index // for a given SFX name. // static int I_SDL_GetSfxLumpNum(sfxinfo_t* sfx) { char namebuf[9]; sprintf(namebuf, "ds%s", DEH_String(sfx->name)); return W_GetNumForName(namebuf); } static void I_SDL_UpdateSoundParams(int handle, int vol, int sep) { int left, right; if (!sound_initialized) { return; } left = ((254 - sep) * vol) / 127; right = ((sep) * vol) / 127; // SDL_mixer version 1.2.8 and earlier has a bug in the Mix_SetPanning // function. A workaround is to call Mix_UnregisterAllEffects for // the channel before calling it. This is undesirable as it may lead // to the channel volumes resetting briefly. if (setpanning_workaround) { Mix_UnregisterAllEffects(handle); } Mix_SetPanning(handle, left, right); } // // Starting a sound means adding it // to the current list of active sounds // in the internal channels. // As the SFX info struct contains // e.g. a pointer to the raw data, // it is ignored. // As our sound handling does not handle // priority, it is ignored. // Pitching (that is, increased speed of playback) // is set, but currently not used by mixing. // static int I_SDL_StartSound(int id, int channel, int vol, int sep) { Mix_Chunk *chunk; if (!sound_initialized) { return -1; } // Release a sound effect if there is already one playing // on this channel ReleaseSoundOnChannel(channel); // Get the sound data chunk = GetSFXChunk(id); if (chunk == NULL) { return -1; } // play sound Mix_PlayChannelTimed(channel, chunk, 0, -1); channels_playing[channel] = id; // set separation, etc. I_SDL_UpdateSoundParams(channel, vol, sep); return channel; } static void I_SDL_StopSound (int handle) { if (!sound_initialized) { return; } Mix_HaltChannel(handle); // Sound data is no longer needed; release the // sound data being used for this channel ReleaseSoundOnChannel(handle); } static boolean I_SDL_SoundIsPlaying(int handle) { if (handle < 0) { return false; } return Mix_Playing(handle); } // // Periodically called to update the sound system // static void I_SDL_UpdateSound(void) { int i; // Check all channels to see if a sound has finished for (i=0; i<NUM_CHANNELS; ++i) { if (channels_playing[i] && !I_SDL_SoundIsPlaying(i)) { // Sound has finished playing on this channel, // but sound data has not been released to cache ReleaseSoundOnChannel(i); } } } static void I_SDL_ShutdownSound(void) { if (!sound_initialized) { return; } Mix_CloseAudio(); SDL_QuitSubSystem(SDL_INIT_AUDIO); sound_initialized = false; } // Calculate slice size, based on MAX_SOUND_SLICE_TIME. // The result must be a power of two. static int GetSliceSize(void) { int limit; int n; limit = (snd_samplerate * MAX_SOUND_SLICE_TIME) / 1000; // Try all powers of two, not exceeding the limit. for (n=0;; ++n) { // 2^n <= limit < 2^n+1 ? if ((1 << (n + 1)) > limit) { return (1 << n); } } // Should never happen? return 1024; } static boolean I_SDL_InitSound(void) { int i; // No sounds yet for (i=0; i<NUMSFX; ++i) { sound_chunks[i].abuf = NULL; } for (i=0; i<NUM_CHANNELS; ++i) { channels_playing[i] = sfx_None; } if (SDL_Init(SDL_INIT_AUDIO) < 0) { fprintf(stderr, "Unable to set up sound.\n"); return false; } if (Mix_OpenAudio(snd_samplerate, AUDIO_S16SYS, 2, GetSliceSize()) < 0) { fprintf(stderr, "Error initializing SDL_mixer: %s\n", Mix_GetError()); return false; } Mix_QuerySpec(&mixer_freq, &mixer_format, &mixer_channels); #ifdef HAVE_LIBSAMPLERATE if (use_libsamplerate != 0) { if (SRC_ConversionMode() < 0) { I_Error("I_SDL_InitSound: Invalid value for use_libsamplerate: %i", use_libsamplerate); } I_PrecacheSounds_SRC(); } #else if (use_libsamplerate != 0) { fprintf(stderr, "I_SDL_InitSound: use_libsamplerate=%i, but " "libsamplerate support not compiled in.\n", use_libsamplerate); } #endif // SDL_mixer version 1.2.8 and earlier has a bug in the Mix_SetPanning // function that can cause the game to lock up. If we're using an old // version, we need to apply a workaround. But the workaround has its // own drawbacks ... { const SDL_version *mixer_version; int v; mixer_version = Mix_Linked_Version(); v = SDL_VERSIONNUM(mixer_version->major, mixer_version->minor, mixer_version->patch); if (v <= SDL_VERSIONNUM(1, 2, 8)) { setpanning_workaround = true; fprintf(stderr, "\n" "ATTENTION: You are using an old version of SDL_mixer!\n" " This version has a bug that may cause " "your sound to stutter.\n" " Please upgrade to a newer version!\n" "\n"); } } Mix_AllocateChannels(NUM_CHANNELS); SDL_PauseAudio(0); sound_initialized = true; return true; } static snddevice_t sound_sdl_devices[] = { SNDDEVICE_SB, SNDDEVICE_PAS, SNDDEVICE_GUS, SNDDEVICE_WAVEBLASTER, SNDDEVICE_SOUNDCANVAS, SNDDEVICE_AWE32, }; sound_module_t sound_sdl_module = { sound_sdl_devices, arrlen(sound_sdl_devices), I_SDL_InitSound, I_SDL_ShutdownSound, I_SDL_GetSfxLumpNum, I_SDL_UpdateSound, I_SDL_UpdateSoundParams, I_SDL_StartSound, I_SDL_StopSound, I_SDL_SoundIsPlaying, };