X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=snd_ogg.c;h=683d4213215f4496ab7bbd74a7b6e4500b496520;hp=7c856ce666c43ee511383c3aca730102bd3f53f2;hb=a79257eab1a7bf88d4403dc6da01063f813f9e71;hpb=478ebd99fcddf34e7fa7a8b47ac4c8f231a1f9dc diff --git a/snd_ogg.c b/snd_ogg.c index 7c856ce6..683d4213 100644 --- a/snd_ogg.c +++ b/snd_ogg.c @@ -27,6 +27,23 @@ #include "snd_ogg.h" #include "snd_wav.h" +#ifdef LINK_TO_LIBVORBIS +#define OV_EXCLUDE_STATIC_CALLBACKS +#include +#include + +#define qov_clear ov_clear +#define qov_info ov_info +#define qov_comment ov_comment +#define qov_open_callbacks ov_open_callbacks +#define qov_pcm_seek ov_pcm_seek +#define qov_pcm_total ov_pcm_total +#define qov_read ov_read +#define qvorbis_comment_query vorbis_comment_query + +qboolean OGG_OpenLibrary (void) {return true;} +void OGG_CloseLibrary (void) {} +#else /* ================================================================= @@ -205,7 +222,7 @@ typedef struct static int (*qov_clear) (OggVorbis_File *vf); static vorbis_info* (*qov_info) (OggVorbis_File *vf,int link); static vorbis_comment* (*qov_comment) (OggVorbis_File *vf,int link); -static char * (*qvorbis_comment_query) (vorbis_comment *vc, char *tag, int count); +static char * (*qvorbis_comment_query) (vorbis_comment *vc, const char *tag, int count); static int (*qov_open_callbacks) (void *datasource, OggVorbis_File *vf, char *initial, long ibytes, ov_callbacks callbacks); @@ -236,63 +253,6 @@ static dllfunction_t vorbisfuncs[] = static dllhandle_t vo_dll = NULL; static dllhandle_t vf_dll = NULL; -typedef struct -{ - unsigned char *buffer; - ogg_int64_t ind, buffsize; -} ov_decode_t; - - -static size_t ovcb_read (void *ptr, size_t size, size_t nb, void *datasource) -{ - ov_decode_t *ov_decode = (ov_decode_t*)datasource; - size_t remain, len; - - remain = ov_decode->buffsize - ov_decode->ind; - len = size * nb; - if (remain < len) - len = remain - remain % size; - - memcpy (ptr, ov_decode->buffer + ov_decode->ind, len); - ov_decode->ind += len; - - return len / size; -} - -static int ovcb_seek (void *datasource, ogg_int64_t offset, int whence) -{ - ov_decode_t *ov_decode = (ov_decode_t*)datasource; - - switch (whence) - { - case SEEK_SET: - break; - case SEEK_CUR: - offset += ov_decode->ind; - break; - case SEEK_END: - offset += ov_decode->buffsize; - break; - default: - return -1; - } - if (offset < 0 || offset > ov_decode->buffsize) - return -1; - - ov_decode->ind = offset; - return 0; -} - -static int ovcb_close (void *ov_decode) -{ - return 0; -} - -static long ovcb_tell (void *ov_decode) -{ - return ((ov_decode_t*)ov_decode)->ind; -} - /* ================================================================= @@ -313,9 +273,8 @@ qboolean OGG_OpenLibrary (void) { const char* dllnames_vo [] = { -#if defined(WIN64) - "libvorbis64.dll", -#elif defined(WIN32) +#if defined(WIN32) + "libvorbis-0.dll", "libvorbis.dll", "vorbis.dll", #elif defined(MACOSX) @@ -328,9 +287,8 @@ qboolean OGG_OpenLibrary (void) }; const char* dllnames_vf [] = { -#if defined(WIN64) - "libvorbisfile64.dll", -#elif defined(WIN32) +#if defined(WIN32) + "libvorbisfile-3.dll", "libvorbisfile.dll", "vorbisfile.dll", #elif defined(MACOSX) @@ -353,16 +311,7 @@ qboolean OGG_OpenLibrary (void) // Load the DLLs // We need to load both by hand because some OSes seem to not load // the vorbis DLL automatically when loading the VorbisFile DLL - if (! Sys_LoadLibrary (dllnames_vo, &vo_dll, vorbisfuncs) || - ! Sys_LoadLibrary (dllnames_vf, &vf_dll, vorbisfilefuncs)) - { - Sys_UnloadLibrary (&vo_dll); - Con_Printf ("Ogg Vorbis support disabled\n"); - return false; - } - - Con_Printf ("Ogg Vorbis support enabled\n"); - return true; + return Sys_LoadLibrary (dllnames_vo, &vo_dll, vorbisfuncs) && Sys_LoadLibrary (dllnames_vf, &vf_dll, vorbisfilefuncs); } @@ -379,6 +328,7 @@ void OGG_CloseLibrary (void) Sys_UnloadLibrary (&vo_dll); } +#endif /* ================================================================= @@ -388,20 +338,67 @@ void OGG_CloseLibrary (void) ================================================================= */ -#define STREAM_BUFFER_DURATION 1.5f // 1.5 sec -#define STREAM_BUFFER_SIZE(format_ptr) ((int)(ceil (STREAM_BUFFER_DURATION * ((format_ptr)->speed * (format_ptr)->width * (format_ptr)->channels)))) +typedef struct +{ + unsigned char *buffer; + ogg_int64_t ind, buffsize; +} ov_decode_t; + +static size_t ovcb_read (void *ptr, size_t size, size_t nb, void *datasource) +{ + ov_decode_t *ov_decode = (ov_decode_t*)datasource; + size_t remain, len; + + remain = ov_decode->buffsize - ov_decode->ind; + len = size * nb; + if (remain < len) + len = remain - remain % size; + + memcpy (ptr, ov_decode->buffer + ov_decode->ind, len); + ov_decode->ind += len; -// We work with 1 sec sequences, so this buffer must be able to contain -// 1 sec of sound of the highest quality (48 KHz, 16 bit samples, stereo) -static unsigned char resampling_buffer [48000 * 2 * 2]; + return len / size; +} +static int ovcb_seek (void *datasource, ogg_int64_t offset, int whence) +{ + ov_decode_t *ov_decode = (ov_decode_t*)datasource; + + switch (whence) + { + case SEEK_SET: + break; + case SEEK_CUR: + offset += ov_decode->ind; + break; + case SEEK_END: + offset += ov_decode->buffsize; + break; + default: + return -1; + } + if (offset < 0 || offset > ov_decode->buffsize) + return -1; + + ov_decode->ind = offset; + return 0; +} + +static int ovcb_close (void *ov_decode) +{ + return 0; +} + +static long ovcb_tell (void *ov_decode) +{ + return ((ov_decode_t*)ov_decode)->ind; +} // Per-sfx data structure typedef struct { unsigned char *file; size_t filesize; - snd_format_t format; } ogg_stream_persfx_t; // Per-channel data structure @@ -409,9 +406,10 @@ typedef struct { OggVorbis_File vf; ov_decode_t ov_decode; - unsigned int sb_offset; int bs; - snd_buffer_t sb; // must be at the end due to its dynamically allocated size + int buffer_firstframe; + int buffer_numframes; + unsigned char buffer[STREAM_BUFFERSIZE*4]; } ogg_stream_perchannel_t; @@ -419,175 +417,110 @@ static const ov_callbacks callbacks = {ovcb_read, ovcb_seek, ovcb_close, ovcb_te /* ==================== -OGG_FetchSound +OGG_GetSamplesFloat ==================== */ -static const snd_buffer_t* OGG_FetchSound (channel_t* ch, unsigned int* start, unsigned int nbsampleframes) +static void OGG_GetSamplesFloat (channel_t *ch, sfx_t *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat) { - ogg_stream_perchannel_t* per_ch; - sfx_t* sfx; - ogg_stream_persfx_t* per_sfx; - snd_buffer_t* sb; - int newlength, done, ret, bigendian; - unsigned int real_start; - unsigned int factor; - - per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data; - sfx = ch->sfx; - per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data; - - // If there's no fetcher structure attached to the channel yet + ogg_stream_perchannel_t *per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data; + ogg_stream_persfx_t *per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data; + int f = sfx->format.width * sfx->format.channels; // bytes per frame in the buffer + short *buf; + int i, len; + int newlength, done, ret; + + // if this channel does not yet have a channel fetcher, make one if (per_ch == NULL) { - size_t buff_len, memsize; - snd_format_t sb_format; - - sb_format.speed = snd_renderbuffer->format.speed; - sb_format.width = per_sfx->format.width; - sb_format.channels = per_sfx->format.channels; - - buff_len = STREAM_BUFFER_SIZE(&sb_format); - memsize = sizeof (*per_ch) - sizeof (per_ch->sb.samples) + buff_len; - per_ch = (ogg_stream_perchannel_t *)Mem_Alloc (snd_mempool, memsize); - sfx->memsize += memsize; - - // Open it with the VorbisFile API + // allocate a struct to keep track of our file position and buffer + per_ch = (ogg_stream_perchannel_t *)Mem_Alloc(snd_mempool, sizeof(*per_ch)); + // begin decoding the file per_ch->ov_decode.buffer = per_sfx->file; per_ch->ov_decode.ind = 0; per_ch->ov_decode.buffsize = per_sfx->filesize; - if (qov_open_callbacks (&per_ch->ov_decode, &per_ch->vf, NULL, 0, callbacks) < 0) + if (qov_open_callbacks(&per_ch->ov_decode, &per_ch->vf, NULL, 0, callbacks) < 0) { - Con_Printf("error while reading Ogg Vorbis stream \"%s\"\n", sfx->name); - Mem_Free (per_ch); - return NULL; + // this never happens - this function succeeded earlier on the same data + Mem_Free(per_ch); + return; } per_ch->bs = 0; - - per_ch->sb_offset = 0; - per_ch->sb.format = sb_format; - per_ch->sb.nbframes = 0; - per_ch->sb.maxframes = buff_len / (per_ch->sb.format.channels * per_ch->sb.format.width); - - ch->fetcher_data = per_ch; - } - - real_start = *start; - - sb = &per_ch->sb; - factor = per_sfx->format.width * per_sfx->format.channels; - - // If the stream buffer can't contain that much samples anyway - if (nbsampleframes > sb->maxframes) - { - Con_Printf ("OGG_FetchSound: stream buffer too small (%u sample frames required)\n", nbsampleframes); - return NULL; + per_ch->buffer_firstframe = 0; + per_ch->buffer_numframes = 0; + // attach the struct to our channel + ch->fetcher_data = (void *)per_ch; } - // If the data we need has already been decompressed in the sfxbuffer, just return it - if (per_ch->sb_offset <= real_start && per_ch->sb_offset + sb->nbframes >= real_start + nbsampleframes) + // if the request is too large for our buffer, loop... + while (numsampleframes * f > (int)sizeof(per_ch->buffer)) { - *start = per_ch->sb_offset; - return sb; + done = sizeof(per_ch->buffer) / f; + OGG_GetSamplesFloat(ch, sfx, firstsampleframe, done, outsamplesfloat); + firstsampleframe += done; + numsampleframes -= done; + outsamplesfloat += done * sfx->format.channels; } - newlength = (int)(per_ch->sb_offset + sb->nbframes) - real_start; - - // If we need to skip some data before decompressing the rest, or if the stream has looped - if (newlength < 0 || per_ch->sb_offset > real_start) + // seek if the request is before the current buffer (loop back) + // seek if the request starts beyond the current buffer by at least one frame (channel was zero volume for a while) + // do not seek if the request overlaps the buffer end at all (expected behavior) + if (per_ch->buffer_firstframe > firstsampleframe || per_ch->buffer_firstframe + per_ch->buffer_numframes < firstsampleframe) { - unsigned int time_start; - ogg_int64_t ogg_start; - int err; - - if (real_start > (unsigned int)sfx->total_length) + // we expect to decode forward from here so this will be our new buffer start + per_ch->buffer_firstframe = firstsampleframe; + per_ch->buffer_numframes = 0; + ret = qov_pcm_seek(&per_ch->vf, (ogg_int64_t)firstsampleframe); + if (ret != 0) { - Con_Printf ("OGG_FetchSound: asked for a start position after the end of the sfx! (%u > %u)\n", - real_start, sfx->total_length); - return NULL; + // LordHavoc: we can't Con_Printf here, not thread safe... + //Con_Printf("OGG_FetchSound: qov_pcm_seek(..., %d) returned %d\n", firstsampleframe, ret); + return; } - - // We work with 200ms (1/5 sec) steps to avoid rounding errors - time_start = real_start * 5 / snd_renderbuffer->format.speed; - ogg_start = time_start * (per_sfx->format.speed / 5); - err = qov_pcm_seek (&per_ch->vf, ogg_start); - if (err != 0) - { - Con_Printf ("OGG_FetchSound: qov_pcm_seek(..., %d) returned %d\n", - real_start, err); - return NULL; - } - sb->nbframes = 0; - - real_start = (float)ogg_start / per_sfx->format.speed * snd_renderbuffer->format.speed; - if (*start - real_start + nbsampleframes > sb->maxframes) - { - Con_Printf ("OGG_FetchSound: stream buffer too small after seek (%u sample frames required)\n", - *start - real_start + nbsampleframes); - per_ch->sb_offset = real_start; - return NULL; - } - } - // Else, move forward the samples we need to keep in the sound buffer - else - { - memmove (sb->samples, sb->samples + (real_start - per_ch->sb_offset) * factor, newlength * factor); - sb->nbframes = newlength; } - per_ch->sb_offset = real_start; - - // We add exactly 1 sec of sound to the buffer: - // 1- to ensure we won't lose any sample during the resampling process - // 2- to force one call to OGG_FetchSound per second to regulate the workload - if (sb->format.speed + sb->nbframes > sb->maxframes) + // decompress the file as needed + if (firstsampleframe + numsampleframes > per_ch->buffer_firstframe + per_ch->buffer_numframes) { - Con_Printf ("OGG_FetchSound: stream buffer overflow (%u sample frames / %u)\n", - sb->format.speed + sb->nbframes, sb->maxframes); - return NULL; + // first slide the buffer back, discarding any data preceding the range we care about + int offset = firstsampleframe - per_ch->buffer_firstframe; + int keeplength = per_ch->buffer_numframes - offset; + if (keeplength > 0) + memmove(per_ch->buffer, per_ch->buffer + offset * sfx->format.width * sfx->format.channels, keeplength * sfx->format.width * sfx->format.channels); + per_ch->buffer_firstframe = firstsampleframe; + per_ch->buffer_numframes -= offset; + // decompress as much as we can fit in the buffer + newlength = sizeof(per_ch->buffer) - per_ch->buffer_numframes * f; + done = 0; + while (newlength > done && (ret = qov_read(&per_ch->vf, (char *)per_ch->buffer + per_ch->buffer_numframes * f + done, (int)(newlength - done), mem_bigendian, 2, 1, &per_ch->bs)) > 0) + done += ret; + // clear the missing space if any + if (done < newlength) + memset(per_ch->buffer + done, 0, newlength - done); + // we now have more data in the buffer + per_ch->buffer_numframes += done / f; } - newlength = per_sfx->format.speed * factor; // -> 1 sec of sound before resampling - if(newlength > (int)sizeof(resampling_buffer)) - newlength = sizeof(resampling_buffer); - - // Decompress in the resampling_buffer -#if BYTE_ORDER == BIG_ENDIAN - bigendian = 1; -#else - bigendian = 0; -#endif - done = 0; - while ((ret = qov_read (&per_ch->vf, (char *)&resampling_buffer[done], (int)(newlength - done), bigendian, 2, 1, &per_ch->bs)) > 0) - done += ret; - - Snd_AppendToSndBuffer (sb, resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format); - *start = per_ch->sb_offset; - return sb; + // convert the sample format for the caller + buf = (short *)((char *)per_ch->buffer + (firstsampleframe - per_ch->buffer_firstframe) * f); + len = numsampleframes * sfx->format.channels; + for (i = 0;i < len;i++) + outsamplesfloat[i] = buf[i] * (1.0f / 32768.0f); } /* ==================== -OGG_FetchEnd +OGG_StopChannel ==================== */ -static void OGG_FetchEnd (channel_t* ch) +static void OGG_StopChannel(channel_t *ch) { - ogg_stream_perchannel_t* per_ch; - - per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data; + ogg_stream_perchannel_t *per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data; if (per_ch != NULL) { - size_t buff_len; - - // Free the ogg vorbis decoder - qov_clear (&per_ch->vf); - - buff_len = per_ch->sb.maxframes * per_ch->sb.format.channels * per_ch->sb.format.width; - ch->sfx->memsize -= sizeof (*per_ch) - sizeof (per_ch->sb.samples) + buff_len; - - Mem_Free (per_ch); - ch->fetcher_data = NULL; + // release the vorbis decompressor + qov_clear(&per_ch->vf); + Mem_Free(per_ch); } } @@ -597,36 +530,68 @@ static void OGG_FetchEnd (channel_t* ch) OGG_FreeSfx ==================== */ -static void OGG_FreeSfx (sfx_t* sfx) +static void OGG_FreeSfx(sfx_t *sfx) { - ogg_stream_persfx_t* per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data; - - // Free the Ogg Vorbis file + ogg_stream_persfx_t *per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data; + // free the complete file we were keeping around Mem_Free(per_sfx->file); - sfx->memsize -= per_sfx->filesize; - - // Free the stream structure + // free the file information structure Mem_Free(per_sfx); - sfx->memsize -= sizeof (*per_sfx); - - sfx->fetcher_data = NULL; - sfx->fetcher = NULL; } -/* -==================== -OGG_GetFormat -==================== -*/ -static const snd_format_t* OGG_GetFormat (sfx_t* sfx) -{ - ogg_stream_persfx_t* per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data; - return &per_sfx->format; -} +static const snd_fetcher_t ogg_fetcher = {OGG_GetSamplesFloat, OGG_StopChannel, OGG_FreeSfx}; -static const snd_fetcher_t ogg_fetcher = { OGG_FetchSound, OGG_FetchEnd, OGG_FreeSfx, OGG_GetFormat }; +static void OGG_DecodeTags(vorbis_comment *vc, unsigned int *start, unsigned int *length, unsigned int numsamples, double *peak, double *gaindb) +{ + const char *startcomment = NULL, *lengthcomment = NULL, *endcomment = NULL, *thiscomment = NULL; + + *start = numsamples; + *length = numsamples; + *peak = 0.0; + *gaindb = 0.0; + + if(!vc) + return; + + thiscomment = qvorbis_comment_query(vc, "REPLAYGAIN_TRACK_PEAK", 0); + if(thiscomment) + *peak = atof(thiscomment); + thiscomment = qvorbis_comment_query(vc, "REPLAYGAIN_TRACK_GAIN", 0); + if(thiscomment) + *gaindb = atof(thiscomment); + + startcomment = qvorbis_comment_query(vc, "LOOP_START", 0); // DarkPlaces, and some Japanese app + if(startcomment) + { + endcomment = qvorbis_comment_query(vc, "LOOP_END", 0); + if(!endcomment) + lengthcomment = qvorbis_comment_query(vc, "LOOP_LENGTH", 0); + } + else + { + startcomment = qvorbis_comment_query(vc, "LOOPSTART", 0); // RPG Maker VX + if(startcomment) + { + lengthcomment = qvorbis_comment_query(vc, "LOOPLENGTH", 0); + if(!lengthcomment) + endcomment = qvorbis_comment_query(vc, "LOOPEND", 0); + } + else + { + startcomment = qvorbis_comment_query(vc, "LOOPPOINT", 0); // Sonic Robo Blast 2 + } + } + if(startcomment) + { + *start = (unsigned int) bound(0, atof(startcomment), numsamples); + if(endcomment) + *length = (unsigned int) bound(0, atof(endcomment), numsamples); + else if(lengthcomment) + *length = (unsigned int) bound(0, *start + atof(lengthcomment), numsamples); + } +} /* ==================== @@ -635,44 +600,46 @@ OGG_LoadVorbisFile Load an Ogg Vorbis file into memory ==================== */ -qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *sfx) +qboolean OGG_LoadVorbisFile(const char *filename, sfx_t *sfx) { unsigned char *data; - const char *loopcomment; fs_offset_t filesize; ov_decode_t ov_decode; OggVorbis_File vf; vorbis_info *vi; vorbis_comment *vc; - ogg_int64_t len, buff_len; + double peak, gaindb; +#ifndef LINK_TO_LIBVORBIS if (!vf_dll) return false; +#endif - // Already loaded? + // Return if already loaded if (sfx->fetcher != NULL) return true; - // Load the file - data = FS_LoadFile (filename, snd_mempool, false, &filesize); + // Load the file completely + data = FS_LoadFile(filename, snd_mempool, false, &filesize); if (data == NULL) return false; - Con_DPrintf ("Loading Ogg Vorbis file \"%s\"\n", filename); + if (developer_loading.integer >= 2) + Con_Printf("Loading Ogg Vorbis file \"%s\"\n", filename); // Open it with the VorbisFile API ov_decode.buffer = data; ov_decode.ind = 0; ov_decode.buffsize = filesize; - if (qov_open_callbacks (&ov_decode, &vf, NULL, 0, callbacks) < 0) + if (qov_open_callbacks(&ov_decode, &vf, NULL, 0, callbacks) < 0) { - Con_Printf ("error while opening Ogg Vorbis file \"%s\"\n", filename); + Con_Printf("error while opening Ogg Vorbis file \"%s\"\n", filename); Mem_Free(data); return false; } // Get the stream information - vi = qov_info (&vf, -1); + vi = qov_info(&vf, -1); if (vi->channels < 1 || vi->channels > 2) { Con_Printf("%s has an unsupported number of channels (%i)\n", @@ -682,93 +649,69 @@ qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *sfx) return false; } - len = qov_pcm_total (&vf, -1) * vi->channels * 2; // 16 bits => "* 2" + sfx->format.speed = vi->rate; + sfx->format.channels = vi->channels; + sfx->format.width = 2; // We always work with 16 bits samples - // Decide if we go for a stream or a simple PCM cache - buff_len = (int)ceil (STREAM_BUFFER_DURATION * (snd_renderbuffer->format.speed * 2 * vi->channels)); - if (snd_streaming.integer && len > (ogg_int64_t)filesize + 3 * buff_len) + sfx->total_length = qov_pcm_total(&vf, -1); + + if (snd_streaming.integer && (snd_streaming.integer >= 2 || sfx->total_length > max(sizeof(ogg_stream_perchannel_t), snd_streaming_length.value * sfx->format.speed))) { + // large sounds use the OGG fetcher to decode the file on demand (but the entire file is held in memory) ogg_stream_persfx_t* per_sfx; - - Con_DPrintf ("\"%s\" will be streamed\n", filename); - per_sfx = (ogg_stream_persfx_t *)Mem_Alloc (snd_mempool, sizeof (*per_sfx)); + if (developer_loading.integer >= 2) + Con_Printf("Ogg sound file \"%s\" will be streamed\n", filename); + per_sfx = (ogg_stream_persfx_t *)Mem_Alloc(snd_mempool, sizeof(*per_sfx)); sfx->memsize += sizeof (*per_sfx); per_sfx->file = data; per_sfx->filesize = filesize; sfx->memsize += filesize; - - per_sfx->format.speed = vi->rate; - per_sfx->format.width = 2; // We always work with 16 bits samples - per_sfx->format.channels = vi->channels; - sfx->fetcher_data = per_sfx; sfx->fetcher = &ogg_fetcher; sfx->flags |= SFXFLAG_STREAMED; - sfx->total_length = (int)((size_t)len / (per_sfx->format.channels * 2) * ((double)snd_renderbuffer->format.speed / per_sfx->format.speed)); - sfx->loopstart = sfx->total_length; vc = qov_comment(&vf, -1); - if(vc) - { - loopcomment = qvorbis_comment_query(vc, "LOOP_START", 0); - if(loopcomment) - sfx->loopstart = bound(0, (unsigned int) (atof(loopcomment) * (double)snd_renderbuffer->format.speed / (double)per_sfx->format.speed), sfx->total_length); - } + OGG_DecodeTags(vc, &sfx->loopstart, &sfx->total_length, sfx->total_length, &peak, &gaindb); + qov_clear(&vf); } else { + // small sounds are entirely loaded and use the PCM fetcher char *buff; + ogg_int64_t len; ogg_int64_t done; - int bs, bigendian; + int bs; long ret; - snd_buffer_t *sb; - snd_format_t ogg_format; - - Con_DPrintf ("\"%s\" will be cached\n", filename); - - // Decode it - buff = (char *)Mem_Alloc (snd_mempool, (int)len); + if (developer_loading.integer >= 2) + Con_Printf ("Ogg sound file \"%s\" will be cached\n", filename); + len = sfx->total_length * sfx->format.channels * sfx->format.width; + sfx->flags &= ~SFXFLAG_STREAMED; + sfx->memsize += len; + sfx->fetcher = &wav_fetcher; + sfx->fetcher_data = Mem_Alloc(snd_mempool, (size_t)len); + buff = (char *)sfx->fetcher_data; done = 0; bs = 0; -#if BYTE_ORDER == BIG_ENDIAN - bigendian = 1; -#else - bigendian = 0; -#endif - while ((ret = qov_read (&vf, &buff[done], (int)(len - done), bigendian, 2, 1, &bs)) > 0) + while ((ret = qov_read(&vf, &buff[done], (int)(len - done), mem_bigendian, 2, 1, &bs)) > 0) done += ret; - - // Build the sound buffer - ogg_format.speed = vi->rate; - ogg_format.channels = vi->channels; - ogg_format.width = 2; // We always work with 16 bits samples - sb = Snd_CreateSndBuffer ((unsigned char *)buff, (size_t)done / (vi->channels * 2), &ogg_format, snd_renderbuffer->format.speed); - if (sb == NULL) - { - qov_clear (&vf); - Mem_Free (data); - Mem_Free (buff); - return false; - } - - sfx->fetcher = &wav_fetcher; - sfx->fetcher_data = sb; - - sfx->total_length = sb->nbframes; - sfx->memsize += sb->maxframes * sb->format.channels * sb->format.width + sizeof (*sb) - sizeof (sb->samples); - - sfx->loopstart = sfx->total_length; - sfx->flags &= ~SFXFLAG_STREAMED; vc = qov_comment(&vf, -1); - if(vc) - { - loopcomment = qvorbis_comment_query(vc, "LOOP_START", 0); - if(loopcomment) - sfx->loopstart = bound(0, (unsigned int) (atoi(loopcomment) * (double)snd_renderbuffer->format.speed / (double)sb->format.speed), sfx->total_length); - } + OGG_DecodeTags(vc, &sfx->loopstart, &sfx->total_length, sfx->total_length, &peak, &gaindb); + qov_clear(&vf); + Mem_Free(data); + } - qov_clear (&vf); - Mem_Free (data); - Mem_Free (buff); + if(peak) + { + sfx->volume_mult = min(1.0f / peak, exp(gaindb * 0.05f * log(10.0f))); + sfx->volume_peak = peak; + if (developer_loading.integer >= 2) + Con_Printf ("Ogg sound file \"%s\" uses ReplayGain (gain %f, peak %f)\n", filename, sfx->volume_mult, sfx->volume_peak); + } + else if(gaindb != 0) + { + sfx->volume_mult = min(1.0f / peak, exp(gaindb * 0.05f * log(10.0f))); + sfx->volume_peak = 1.0; // if peak is not defined, we won't trust it + if (developer_loading.integer >= 2) + Con_Printf ("Ogg sound file \"%s\" uses ReplayGain (gain %f, peak not defined and assumed to be %f)\n", filename, sfx->volume_mult, sfx->volume_peak); } return true;