change default snd_soundradius back to 1000, matching Quake
[divverent/darkplaces.git] / snd_ogg.c
index 7e37fe7..e383655 100644 (file)
--- a/snd_ogg.c
+++ b/snd_ogg.c
 #include "snd_ogg.h"
 #include "snd_wav.h"
 
+#ifdef LINK_TO_LIBVORBIS
+#define OV_EXCLUDE_STATIC_CALLBACKS
+#include <ogg/ogg.h>
+#include <vorbis/vorbisfile.h>
+
+#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
 
 /*
 =================================================================
@@ -158,6 +175,14 @@ typedef struct
        void                            *internal;
 } vorbis_block;
 
+typedef struct
+{
+       char **user_comments;
+       int   *comment_lengths;
+       int    comments;
+       char  *vendor;
+} vorbis_comment;
+
 typedef struct
 {
        void                            *datasource;
@@ -171,7 +196,7 @@ typedef struct
        long                            *serialnos;
        ogg_int64_t                     *pcmlengths;
        vorbis_info                     *vi;
-       void                            *vc;  // VOIDED POINTER
+       vorbis_comment          *vc;
        ogg_int64_t                     pcm_offset;
        int                                     ready_state;
        long                            current_serialno;
@@ -196,6 +221,8 @@ typedef struct
 // Functions exported from the vorbisfile library
 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, const char *tag, int count);
 static int (*qov_open_callbacks) (void *datasource, OggVorbis_File *vf,
                                                                  char *initial, long ibytes,
                                                                  ov_callbacks callbacks);
@@ -204,14 +231,21 @@ static ogg_int64_t (*qov_pcm_total) (OggVorbis_File *vf,int i);
 static long (*qov_read) (OggVorbis_File *vf,char *buffer,int length,
                                                 int bigendianp,int word,int sgned,int *bitstream);
 
-static dllfunction_t oggvorbisfuncs[] =
+static dllfunction_t vorbisfilefuncs[] =
+{
+       {"ov_clear",                            (void **) &qov_clear},
+       {"ov_info",                                     (void **) &qov_info},
+       {"ov_comment",                          (void **) &qov_comment},
+       {"ov_open_callbacks",           (void **) &qov_open_callbacks},
+       {"ov_pcm_seek",                         (void **) &qov_pcm_seek},
+       {"ov_pcm_total",                        (void **) &qov_pcm_total},
+       {"ov_read",                                     (void **) &qov_read},
+       {NULL, NULL}
+};
+
+static dllfunction_t vorbisfuncs[] =
 {
-       {"ov_clear",                    (void **) &qov_clear},
-       {"ov_info",                             (void **) &qov_info},
-       {"ov_open_callbacks",   (void **) &qov_open_callbacks},
-       {"ov_pcm_seek",                 (void **) &qov_pcm_seek},
-       {"ov_pcm_total",                (void **) &qov_pcm_total},
-       {"ov_read",                             (void **) &qov_read},
+       {"vorbis_comment_query",        (void **) &qvorbis_comment_query},
        {NULL, NULL}
 };
 
@@ -219,63 +253,6 @@ static dllfunction_t oggvorbisfuncs[] =
 static dllhandle_t vo_dll = NULL;
 static dllhandle_t vf_dll = NULL;
 
-typedef struct
-{
-       qbyte *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;
-}
-
 
 /*
 =================================================================
@@ -296,9 +273,9 @@ qboolean OGG_OpenLibrary (void)
 {
        const char* dllnames_vo [] =
        {
-#if defined(WIN64)
-               "vorbis64.dll",
-#elif defined(WIN32)
+#if defined(WIN32)
+               "libvorbis-0.dll",
+               "libvorbis.dll",
                "vorbis.dll",
 #elif defined(MACOSX)
                "libvorbis.dylib",
@@ -310,9 +287,9 @@ qboolean OGG_OpenLibrary (void)
        };
        const char* dllnames_vf [] =
        {
-#if defined(WIN64)
-               "vorbisfile64.dll",
-#elif defined(WIN32)
+#if defined(WIN32)
+               "libvorbisfile-3.dll",
+               "libvorbisfile.dll",
                "vorbisfile.dll",
 #elif defined(MACOSX)
                "libvorbisfile.dylib",
@@ -334,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, NULL) ||
-               ! Sys_LoadLibrary (dllnames_vf, &vf_dll, oggvorbisfuncs))
-       {
-               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);
 }
 
 
@@ -360,6 +328,7 @@ void OGG_CloseLibrary (void)
        Sys_UnloadLibrary (&vo_dll);
 }
 
+#endif
 
 /*
 =================================================================
@@ -369,20 +338,70 @@ void OGG_CloseLibrary (void)
 =================================================================
 */
 
-#define STREAM_BUFFER_DURATION 1.5f    // 1.5 sec
-#define STREAM_BUFFER_SIZE(format_ptr) (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;
+
+       return len / size;
+}
+
+static int ovcb_seek (void *datasource, ogg_int64_t offset, int whence)
+{
+       ov_decode_t *ov_decode = (ov_decode_t*)datasource;
 
-// 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 qbyte resampling_buffer [48000 * 2 * 2];
+       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
 {
-       qbyte                   *file;
+       unsigned char   *file;
        size_t                  filesize;
        snd_format_t    format;
+       unsigned int    total_length;
+       char                    name[128];
 } ogg_stream_persfx_t;
 
 // Per-channel data structure
@@ -390,8 +409,9 @@ typedef struct
 {
        OggVorbis_File  vf;
        ov_decode_t             ov_decode;
+       unsigned int    sb_offset;
        int                             bs;
-       sfxbuffer_t             sb;             // must be at the end due to its dynamically allocated size
+       snd_buffer_t    sb;             // must be at the end due to its dynamically allocated size
 } ogg_stream_perchannel_t;
 
 
@@ -402,33 +422,28 @@ static const ov_callbacks callbacks = {ovcb_read, ovcb_seek, ovcb_close, ovcb_te
 OGG_FetchSound
 ====================
 */
-static const sfxbuffer_t* OGG_FetchSound (channel_t* ch, unsigned int start, unsigned int nbsamples)
+static const snd_buffer_t* OGG_FetchSound (void *sfxfetcher, void **chfetcherpointer, unsigned int *start, unsigned int nbsampleframes)
 {
-       ogg_stream_perchannel_t* per_ch;
-       sfxbuffer_t* sb;
-       sfx_t* sfx;
-       snd_format_t* format;
-       ogg_stream_persfx_t* per_sfx;
-       int newlength, done, ret, bigendian;
+       ogg_stream_perchannel_t* per_ch = (ogg_stream_perchannel_t *)*chfetcherpointer;
+       ogg_stream_persfx_t* per_sfx = (ogg_stream_persfx_t *)sfxfetcher;
+       snd_buffer_t* sb;
+       int newlength, done, ret;
+       unsigned int real_start;
        unsigned int factor;
-       size_t buff_len;
-
-       per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data;
-       sfx = ch->sfx;
-       per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data;
-       format = &sfx->format;
-       buff_len = STREAM_BUFFER_SIZE(format);
 
        // If there's no fetcher structure attached to the channel yet
        if (per_ch == NULL)
        {
-               size_t memsize;
-               ogg_stream_persfx_t* per_sfx;
+               size_t buff_len, memsize;
+               snd_format_t sb_format;
 
-               memsize = sizeof (*per_ch) - sizeof (per_ch->sb.data) + buff_len;
+               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;
-               per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data;
 
                // Open it with the VorbisFile API
                per_ch->ov_decode.buffer = per_sfx->file;
@@ -436,75 +451,107 @@ static const sfxbuffer_t* OGG_FetchSound (channel_t* ch, unsigned int start, uns
                per_ch->ov_decode.buffsize = per_sfx->filesize;
                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);
+                       Con_Printf("error while reading Ogg Vorbis stream \"%s\"\n", per_sfx->name);
                        Mem_Free (per_ch);
                        return NULL;
                }
-
-               per_ch->sb.offset = 0;
-               per_ch->sb.length = 0;
                per_ch->bs = 0;
 
-               ch->fetcher_data = per_ch;
+               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);
+
+               *chfetcherpointer = 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 (nbsamples * factor > buff_len)
+       if (nbsampleframes > sb->maxframes)
        {
-               Con_Printf ("OGG_FetchSound: stream buffer too small (%u bytes required)\n", nbsamples * factor);
+               Con_Printf ("OGG_FetchSound: stream buffer too small (%u sample frames required)\n", nbsampleframes);
                return NULL;
        }
 
        // If the data we need has already been decompressed in the sfxbuffer, just return it
-       if (sb->offset <= start && sb->offset + sb->length >= start + nbsamples)
+       if (per_ch->sb_offset <= real_start && per_ch->sb_offset + sb->nbframes >= real_start + nbsampleframes)
+       {
+               *start = per_ch->sb_offset;
                return sb;
+       }
 
-       newlength = (int)(sb->offset + sb->length) - start;
+       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 || sb->offset > start)
+       if (newlength < 0 || per_ch->sb_offset > real_start)
        {
-               if (qov_pcm_seek (&per_ch->vf, (ogg_int64_t)start) != 0)
+               unsigned int time_start;
+               ogg_int64_t ogg_start;
+               int err;
+
+               if (real_start > (unsigned int)per_sfx->total_length)
+               {
+                       Con_Printf ("OGG_FetchSound: asked for a start position after the end of the sfx! (%u > %u)\n",
+                                               real_start, per_sfx->total_length);
+                       return NULL;
+               }
+
+               // 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 = (unsigned int) ((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;
-               sb->length = 0;
+               }
        }
-       // Else, move forward the samples we need to keep in the sfxbuffer
+       // Else, move forward the samples we need to keep in the sound buffer
        else
        {
-               memmove (sb->data, sb->data + (start - sb->offset) * factor, newlength * factor);
-               sb->length = newlength;
+               memmove (sb->samples, sb->samples + (real_start - per_ch->sb_offset) * factor, newlength * factor);
+               sb->nbframes = newlength;
        }
 
-       sb->offset = start;
+       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 ((sfx->format.speed + sb->length) * factor > buff_len)
+       // We add more than one frame of sound to the buffer:
+       // 1- to ensure we won't lose many samples during the resampling process
+       // 2- to reduce calls to OGG_FetchSound to regulate workload
+       newlength = (int)(per_sfx->format.speed*STREAM_BUFFER_FILL);
+       if (newlength + sb->nbframes > sb->maxframes)
        {
-               Con_Printf ("OGG_FetchSound: stream buffer overflow (%u bytes / %u)\n",
-                                       (sfx->format.speed + sb->length) * factor, buff_len);
+               Con_Printf ("OGG_FetchSound: stream buffer overflow (%u + %u = %u sample frames / %u)\n",
+                                       newlength, sb->nbframes, newlength + sb->nbframes, sb->maxframes);
                return NULL;
        }
-       newlength = per_sfx->format.speed * factor;  // -> 1 sec of sound before resampling
+       newlength *= factor; // convert from sample frames to bytes
+       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)
+       while ((ret = qov_read (&per_ch->vf, (char *)&resampling_buffer[done], (int)(newlength - done), mem_bigendian, 2, 1, &per_ch->bs)) > 0)
                done += ret;
 
-       // Resample in the sfxbuffer
-       newlength = (int)ResampleSfx (resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format, sb->data + sb->length * (size_t)factor, sfx->name);
-       sb->length += newlength;
+       Snd_AppendToSndBuffer (sb, resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format);
 
+       *start = per_ch->sb_offset;
        return sb;
 }
 
@@ -514,25 +561,16 @@ static const sfxbuffer_t* OGG_FetchSound (channel_t* ch, unsigned int start, uns
 OGG_FetchEnd
 ====================
 */
-static void OGG_FetchEnd (channel_t* ch)
+static void OGG_FetchEnd (void *chfetcherdata)
 {
-       ogg_stream_perchannel_t* per_ch;
+       ogg_stream_perchannel_t* per_ch = (ogg_stream_perchannel_t *)chfetcherdata;
 
-       per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data;
        if (per_ch != NULL)
        {
-               size_t buff_len;
-               snd_format_t* format;
-
                // Free the ogg vorbis decoder
                qov_clear (&per_ch->vf);
 
                Mem_Free (per_ch);
-               ch->fetcher_data = NULL;
-
-               format = &ch->sfx->format;
-               buff_len = STREAM_BUFFER_SIZE(format);
-               ch->sfx->memsize -= sizeof (*per_ch) - sizeof (per_ch->sb.data) + buff_len;
        }
 }
 
@@ -542,24 +580,81 @@ static void OGG_FetchEnd (channel_t* ch)
 OGG_FreeSfx
 ====================
 */
-static void OGG_FreeSfx (sfx_t* sfx)
+static void OGG_FreeSfx (void *sfxfetcherdata)
 {
-       ogg_stream_persfx_t* per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data;
+       ogg_stream_persfx_t* per_sfx = (ogg_stream_persfx_t *)sfxfetcherdata;
 
        // Free the Ogg Vorbis file
        Mem_Free(per_sfx->file);
-       sfx->memsize -= per_sfx->filesize;
 
        // Free the stream 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_FetchSound, OGG_FetchEnd, 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, double samplesfactor, 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) * samplesfactor, numsamples);
+               if(endcomment)
+                       *length = (unsigned int) bound(0, atof(endcomment) * samplesfactor, numsamples);
+               else if(lengthcomment)
+                       *length = (unsigned int) bound(0, *start + atof(lengthcomment) * samplesfactor, numsamples);
+       }
+}
 
 /*
 ====================
@@ -568,32 +663,38 @@ OGG_LoadVorbisFile
 Load an Ogg Vorbis file into memory
 ====================
 */
-qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *s)
+qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *sfx)
 {
-       qbyte *data;
+       unsigned char *data;
+       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?
-       if (s->fetcher != NULL)
+       if (sfx->fetcher != NULL)
                return true;
 
        // Load the file
-       data = FS_LoadFile (filename, snd_mempool, false);
+       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 = fs_filesize;
+       ov_decode.buffsize = filesize;
        if (qov_open_callbacks (&ov_decode, &vf, NULL, 0, callbacks) < 0)
        {
                Con_Printf ("error while opening Ogg Vorbis file \"%s\"\n", filename);
@@ -606,7 +707,7 @@ qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *s)
        if (vi->channels < 1 || vi->channels > 2)
        {
                Con_Printf("%s has an unsupported number of channels (%i)\n",
-                                       s->name, vi->channels);
+                                       sfx->name, vi->channels);
                qov_clear (&vf);
                Mem_Free(data);
                return false;
@@ -615,78 +716,87 @@ qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *s)
        len = qov_pcm_total (&vf, -1) * vi->channels * 2;  // 16 bits => "* 2"
 
        // Decide if we go for a stream or a simple PCM cache
-       buff_len = ceil (STREAM_BUFFER_DURATION * (shm->format.speed * 2 * vi->channels));
-       if (snd_streaming.integer && len > (ogg_int64_t)fs_filesize + 3 * buff_len)
+       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 || snd_streaming.integer >= 2))
        {
                ogg_stream_persfx_t* per_sfx;
 
-               Con_DPrintf ("\"%s\" will be streamed\n", filename);
+               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));
-               s->memsize += sizeof (*per_sfx);
+               strlcpy(per_sfx->name, sfx->name, sizeof(per_sfx->name));
+               sfx->memsize += sizeof (*per_sfx);
                per_sfx->file = data;
-               per_sfx->filesize = fs_filesize;
-               s->memsize += fs_filesize;
+               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;
-               s->format.speed = shm->format.speed;
-               s->format.width = per_sfx->format.width;
-               s->format.channels = per_sfx->format.channels;
-
-               s->fetcher_data = per_sfx;
-               s->fetcher = &ogg_fetcher;
-               s->loopstart = -1;
-               s->flags |= SFXFLAG_STREAMED;
-               s->total_length = (size_t)len / per_sfx->format.channels / 2 * ((float)s->format.speed / per_sfx->format.speed);
+
+               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));
+               vc = qov_comment(&vf, -1);
+               OGG_DecodeTags(vc, &sfx->loopstart, &sfx->total_length, (double)snd_renderbuffer->format.speed / (double)per_sfx->format.speed, sfx->total_length, &peak, &gaindb);
+               per_sfx->total_length = sfx->total_length;
+               qov_clear (&vf);
        }
        else
        {
                char *buff;
                ogg_int64_t done;
-               int bs, bigendian;
+               int bs;
                long ret;
-               sfxbuffer_t *sb;
-               size_t memsize;
+               snd_buffer_t *sb;
+               snd_format_t ogg_format;
 
-               Con_DPrintf ("\"%s\" will be cached\n", filename);
+               if (developer_loading.integer >= 2)
+                       Con_Printf ("Ogg sound file \"%s\" will be cached\n", filename);
 
                // Decode it
                buff = (char *)Mem_Alloc (snd_mempool, (int)len);
                done = 0;
                bs = 0;
-#if BYTE_ORDER == LITTLE_ENDIAN
-               bigendian = 0;
-#else
-               bigendian = 1;
-#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;
 
-               // Calculate resampled length
-               len = (double)done * (double)shm->format.speed / (double)vi->rate;
-
-               // Resample it
-               memsize = (size_t)len + sizeof (*sb) - sizeof (sb->data);
-               sb = (sfxbuffer_t *)Mem_Alloc (snd_mempool, memsize);
-               s->memsize += memsize;
-               s->fetcher_data = sb;
-               s->fetcher = &wav_fetcher;
-               s->format.speed = vi->rate;
-               s->format.width = 2;  // We always work with 16 bits samples
-               s->format.channels = vi->channels;
-               s->loopstart = -1;
-               s->flags &= ~SFXFLAG_STREAMED;
-
-               sb->length = (unsigned int)ResampleSfx ((qbyte *)buff, (size_t)done / (vi->channels * 2), &s->format, sb->data, s->name);
-               s->format.speed = shm->format.speed;
-               s->total_length = sb->length;
-               sb->offset = 0;
+               // 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->flags &= ~SFXFLAG_STREAMED;
+               vc = qov_comment(&vf, -1);
+               OGG_DecodeTags(vc, &sfx->loopstart, &sfx->total_length, (double)snd_renderbuffer->format.speed / (double)sb->format.speed, sfx->total_length, &peak, &gaindb);
+               sb->nbframes = sfx->total_length;
                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);
+       }
+
        return true;
 }