X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=snd_ogg.c;h=8a2682031d86fae844ec8c21601fc67c3ab5d9e5;hb=b3f5f964484b851ef9eb6b714780210693462b4c;hp=8acedc7c3d0362ede540b6fc821caf3b6f509136;hpb=355bc09086e3ff04769e90565df100e510f852da;p=xonotic%2Fdarkplaces.git diff --git a/snd_ogg.c b/snd_ogg.c index 8acedc7c..8a268203 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,283 @@ 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; + unsigned int sb_offset; + int bs; + snd_buffer_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 snd_buffer_t* OGG_FetchSound (channel_t* ch, unsigned int* start, unsigned int nbsampleframes) +{ + 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 + 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 + 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->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; + } + + // 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) + { + *start = per_ch->sb_offset; + return sb; + } + + 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) + { + unsigned int time_start; + ogg_int64_t ogg_start; + int err; + + if (real_start > sfx->total_length) + { + 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; + } + + // 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) + { + Con_Printf ("OGG_FetchSound: stream buffer overflow (%u sample frames / %u)\n", + sb->format.speed + sb->nbframes, sb->maxframes); + 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; + + Snd_AppendToSndBuffer (sb, resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format); + + *start = per_ch->sb_offset; + 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; + + // 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; + } +} + + +/* +==================== +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; +} + + +/* +==================== +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, OGG_GetFormat }; + + /* ==================== 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 *sfx) { - 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 (sfx->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 @@ -400,51 +655,86 @@ sfxcache_t *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 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 * (snd_renderbuffer->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)); + 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->loopstart = -1; + 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)); } 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; + 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); + 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) + 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; - qov_clear (&vf); - Mem_Free (buff); - Mem_Free (data); + sfx->total_length = sb->nbframes; + sfx->memsize += sb->maxframes * sb->format.channels * sb->format.width + sizeof (*sb) - sizeof (sb->samples); - return sc; + sfx->loopstart = -1; + sfx->flags &= ~SFXFLAG_STREAMED; + + qov_clear (&vf); + Mem_Free (data); + Mem_Free (buff); + } + + return true; }