X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=snd_ogg.c;h=b0073d263f6a9b9b5d9efe98379654b8c70fd203;hb=16dee271a7e503a49993c5f934aeb6eb45c19ae1;hp=8acedc7c3d0362ede540b6fc821caf3b6f509136;hpb=355bc09086e3ff04769e90565df100e510f852da;p=xonotic%2Fdarkplaces.git diff --git a/snd_ogg.c b/snd_ogg.c index 8acedc7c..b0073d26 100644 --- a/snd_ogg.c +++ b/snd_ogg.c @@ -1,5 +1,5 @@ /* - Copyright (C) 2003 Mathieu Olivier + Copyright (C) 2003-2005 Mathieu Olivier This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License @@ -23,10 +23,9 @@ #include "quakedef.h" +#include "snd_main.h" #include "snd_ogg.h" - - -extern void ResampleSfx (sfxcache_t *sc, qbyte *data, char *name); +#include "snd_wav.h" /* @@ -200,6 +199,7 @@ static vorbis_info* (*qov_info) (OggVorbis_File *vf,int link); static int (*qov_open_callbacks) (void *datasource, OggVorbis_File *vf, char *initial, long ibytes, ov_callbacks callbacks); +static int (*qov_pcm_seek) (OggVorbis_File *vf,ogg_int64_t pos); 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); @@ -209,17 +209,19 @@ static dllfunction_t oggvorbisfuncs[] = {"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}, {NULL, NULL} }; -// Handle for the Vorbisfile DLL +// Handles for the Vorbis and Vorbisfile DLLs +static dllhandle_t vo_dll = NULL; static dllhandle_t vf_dll = NULL; typedef struct { - qbyte *buffer; + unsigned char *buffer; ogg_int64_t ind, buffsize; } ov_decode_t; @@ -292,40 +294,57 @@ Try to load the VorbisFile DLL */ qboolean OGG_OpenLibrary (void) { - const char* dllname; - const dllfunction_t *func; + const char* dllnames_vo [] = + { +#if defined(WIN64) + "libvorbis64.dll", +#elif defined(WIN32) + "libvorbis.dll", + "vorbis.dll", +#elif defined(MACOSX) + "libvorbis.dylib", +#else + "libvorbis.so.0", + "libvorbis.so", +#endif + NULL + }; + const char* dllnames_vf [] = + { +#if defined(WIN64) + "libvorbisfile64.dll", +#elif defined(WIN32) + "libvorbisfile.dll", + "vorbisfile.dll", +#elif defined(MACOSX) + "libvorbisfile.dylib", +#else + "libvorbisfile.so.3", + "libvorbisfile.so", +#endif + NULL + }; // Already loaded? if (vf_dll) return true; -#ifdef WIN32 - dllname = "vorbisfile.dll"; -#else - dllname = "libvorbisfile.so"; -#endif - - // Initializations - for (func = oggvorbisfuncs; func && func->name != NULL; func++) - *func->funcvariable = NULL; +// COMMANDLINEOPTION: Sound: -novorbis disables ogg vorbis sound support + if (COM_CheckParm("-novorbis")) + return false; - // Load the DLL - if (! (vf_dll = Sys_LoadLibrary (dllname))) + // 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)) { - Con_DPrintf("Can't find %s. Ogg Vorbis support disabled\n", dllname); + Sys_UnloadLibrary (&vo_dll); + Con_Printf ("Ogg Vorbis support disabled\n"); return false; } - // Get the function adresses - for (func = oggvorbisfuncs; func && func->name != NULL; func++) - if (!(*func->funcvariable = (void *) Sys_GetProcAddress (vf_dll, func->name))) - { - Con_Printf("missing function \"%s\" - broken Ogg Vorbis library!\n", func->name); - OGG_CloseLibrary (); - return false; - } - - Con_DPrintf("%s loaded. Ogg Vorbis support enabled\n", dllname); + Con_Printf ("Ogg Vorbis support enabled\n"); return true; } @@ -339,11 +358,8 @@ Unload the VorbisFile DLL */ void OGG_CloseLibrary (void) { - if (!vf_dll) - return; - - Sys_UnloadLibrary (vf_dll); - vf_dll = NULL; + Sys_UnloadLibrary (&vf_dll); + Sys_UnloadLibrary (&vo_dll); } @@ -355,44 +371,237 @@ 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)))) + +// 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]; + + +// Per-sfx data structure +typedef struct +{ + unsigned char *file; + size_t filesize; + snd_format_t format; +} ogg_stream_persfx_t; + +// Per-channel data structure +typedef struct +{ + OggVorbis_File vf; + ov_decode_t ov_decode; + int bs; + sfxbuffer_t sb; // must be at the end due to its dynamically allocated size +} ogg_stream_perchannel_t; + + +static const ov_callbacks callbacks = {ovcb_read, ovcb_seek, ovcb_close, ovcb_tell}; + +/* +==================== +OGG_FetchSound +==================== +*/ +static const sfxbuffer_t* OGG_FetchSound (channel_t* ch, unsigned int start, unsigned int nbsamples) +{ + 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; + 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; + + memsize = sizeof (*per_ch) - sizeof (per_ch->sb.data) + 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; + 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) + { + Con_Printf("error while reading Ogg Vorbis stream \"%s\"\n", 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; + } + + 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) + { + Con_Printf ("OGG_FetchSound: stream buffer too small (%u bytes required)\n", nbsamples * factor); + 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) + return sb; + + newlength = (int)(sb->offset + sb->length) - 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 (qov_pcm_seek (&per_ch->vf, (ogg_int64_t)start) != 0) + return NULL; + sb->length = 0; + } + // Else, move forward the samples we need to keep in the sfxbuffer + else + { + memmove (sb->data, sb->data + (start - sb->offset) * factor, newlength * factor); + sb->length = newlength; + } + + sb->offset = 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) + { + Con_Printf ("OGG_FetchSound: stream buffer overflow (%u bytes / %u)\n", + (sfx->format.speed + sb->length) * factor, buff_len); + return NULL; + } + newlength = per_sfx->format.speed * factor; // -> 1 sec of sound before resampling + + // 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; + + // 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; + + return sb; +} + + +/* +==================== +OGG_FetchEnd +==================== +*/ +static void OGG_FetchEnd (channel_t* ch) +{ + ogg_stream_perchannel_t* per_ch; + + 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; + } +} + + +/* +==================== +OGG_FreeSfx +==================== +*/ +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 + 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; +} + +static const snd_fetcher_t ogg_fetcher = { OGG_FetchSound, OGG_FetchEnd, OGG_FreeSfx }; + + /* ==================== OGG_LoadVorbisFile -Load an Ogg Vorbis file into a sfxcache_t +Load an Ogg Vorbis file into memory ==================== */ -sfxcache_t *OGG_LoadVorbisFile (const char *filename, sfx_t *s) +qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *s) { - qbyte *data; + unsigned char *data; + fs_offset_t filesize; ov_decode_t ov_decode; OggVorbis_File vf; - ov_callbacks callbacks = {ovcb_read, ovcb_seek, ovcb_close, ovcb_tell}; vorbis_info *vi; - ogg_int64_t len; - char *buff; - ogg_int64_t done; - int bs, bigendian; - long ret; - sfxcache_t *sc; + ogg_int64_t len, buff_len; if (!vf_dll) - return NULL; + return false; + + // Already loaded? + if (s->fetcher != NULL) + return true; // Load the file - data = FS_LoadFile (filename, false); + data = FS_LoadFile (filename, snd_mempool, false, &filesize); if (data == NULL) - return NULL; + return false; + + Con_DPrintf ("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); - Mem_Free (data); - return NULL; + Con_Printf ("error while opening Ogg Vorbis file \"%s\"\n", filename); + Mem_Free(data); + return false; } // Get the stream information @@ -402,49 +611,86 @@ sfxcache_t *OGG_LoadVorbisFile (const char *filename, sfx_t *s) Con_Printf("%s has an unsupported number of channels (%i)\n", s->name, vi->channels); qov_clear (&vf); - Mem_Free (data); - return NULL; + Mem_Free(data); + return false; } - // Decode it len = qov_pcm_total (&vf, -1) * vi->channels * 2; // 16 bits => "* 2" - buff = Mem_Alloc (tempmempool, (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) - done += ret; - - // Calculate resampled length - len = (double)done * (double)shm->speed / (double)vi->rate; - // Resample it - Mem_FreePool (&s->mempool); - s->mempool = Mem_AllocPool (s->name); - sc = s->sfxcache = Mem_Alloc (s->mempool, (int)len + sizeof (sfxcache_t)); - if (sc != NULL) + // Decide if we go for a stream or a simple PCM cache + buff_len = (int)ceil (STREAM_BUFFER_DURATION * (shm->format.speed * 2 * vi->channels)); + if (snd_streaming.integer && len > (ogg_int64_t)filesize + 3 * buff_len) { - sc->length = (int)done / (vi->channels * 2); - sc->loopstart = -1; - sc->speed = vi->rate; - sc->width = 2; // We always work with 16 bits samples - sc->stereo = (vi->channels == 2); - - ResampleSfx (sc, buff, s->name); + 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)); + s->memsize += sizeof (*per_sfx); + per_sfx->file = data; + per_sfx->filesize = filesize; + s->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 = (int)((size_t)len / per_sfx->format.channels / 2 * ((float)s->format.speed / per_sfx->format.speed)); } else { - Con_Printf("failed to allocate memory for sound \"%s\"\n", s->name); - Mem_FreePool (&s->mempool); - } + char *buff; + ogg_int64_t done; + int bs, bigendian; + long ret; + sfxbuffer_t *sb; + size_t memsize; + + Con_DPrintf ("\"%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) + done += ret; + + // Calculate resampled length + // FIXME: is this using the correct rounding direction? ceil may be better + len = (int)((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 ((unsigned char *)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; - qov_clear (&vf); - Mem_Free (buff); - Mem_Free (data); + qov_clear (&vf); + Mem_Free (data); + Mem_Free (buff); + } - return sc; + return true; }