// Allocate a new sound chunk and pitch-shift an existing sound up-or-down // into it. static allocated_sound_t *PitchShift(allocated_sound_t *insnd, int pitch) { allocated_sound_t *outsnd; Sint16 *inp, *outp; Sint16 *srcbuf, *dstbuf; Uint32 srclen, dstlen; srcbuf = (Sint16 *)insnd->chunk.abuf; srclen = insnd->chunk.alen; // determine ratio pitch:NORM_PITCH and apply to srclen, then invert. // This is an approximation of vanilla behaviour based on measurements dstlen = (int)((1 + (1 - (float)pitch / NORM_PITCH)) * srclen); // ensure that the new buffer is an even length if (!(dstlen % 2)) ++dstlen; outsnd = AllocateSound(insnd->sfxinfo, dstlen); if (!outsnd) return NULL; outsnd->pitch = pitch; dstbuf = (Sint16 *)outsnd->chunk.abuf; // loop over output buffer. find corresponding input cell, copy over for (outp = dstbuf; outp < dstbuf + dstlen / 2; ++outp) { inp = srcbuf + (int)((float)(outp - dstbuf) / dstlen * srclen); *outp = *inp; } return outsnd; }
void SndCopyToPool() { for (uint i = 0; i < ORIGINAL_SAMPLE_COUNT; i++) { SoundEntry *sound = AllocateSound(); *sound = _original_sounds[_sound_idx[i]]; sound->volume = _sound_base_vol[i]; sound->priority = 0; } }
static short StartQL(void) { short e; e=QL_memory(); if(e==0) { e=LoadRoms(); if(e==0) { InitSerial(); RestartQL(); e=AllocateDisk(); if(e==0) e=AllocateSound(); if(e==0) { qlRunning=true; StartTimer(); } else DisposePtr((Ptr)theROM); } else DisposePtr((Ptr)theROM); } return e; }
// Generic sound expansion function for any sample rate. // Returns number of clipped samples (always 0). static dboolean ExpandSoundData(sfxinfo_t *sfxinfo, byte *data, int samplerate, int length) { SDL_AudioCVT convertor; allocated_sound_t *snd; Mix_Chunk *chunk; 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; // Allocate a chunk in which to expand the sound snd = AllocateSound(sfxinfo, expanded_length); if (!snd) return false; chunk = &snd->chunk; // 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 = chunk->abuf; convertor.len = length; memcpy(convertor.buf, data, length); SDL_ConvertAudio(&convertor); } else { Sint16 *expanded = (Sint16 *)chunk->abuf; int expand_ratio; unsigned 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)) - 32768; // expand 8->16 bits, mono->stereo expanded[i * 2] = expanded[i * 2 + 1] = sample; } { 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 / (float)(2 * M_PI * 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]); } } return true; }
static boolean ExpandSoundData_SRC(sfxinfo_t *sfxinfo, byte *data, int samplerate, int length) { SRC_DATA src_data; uint32_t i, abuf_index=0, clipped=0; uint32_t alen; int retn; int16_t *expanded; Mix_Chunk *chunk; src_data.input_frames = length; src_data.data_in = malloc(length * sizeof(float)); 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. src_data.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; chunk = AllocateSound(sfxinfo, src_data.output_frames_gen * 4); if (chunk == NULL) { return false; } 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(src_data.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; }