X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=snd_ogg.c;h=9016656f9d361c68cca3b4c9a27b9b9d5e2be51a;hp=7cba800bb8de0704a32cb67105cb36a46fa9e37b;hb=6a7922a15331ef5065c7637a04d2c78a076f840c;hpb=9fa8ce6f31c95105ed4ac684b37f79f133b9c960 diff --git a/snd_ogg.c b/snd_ogg.c index 7cba800b..9016656f 100644 --- a/snd_ogg.c +++ b/snd_ogg.c @@ -158,6 +158,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 +179,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 +204,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, char *tag, int count); static int (*qov_open_callbacks) (void *datasource, OggVorbis_File *vf, char *initial, long ibytes, ov_callbacks callbacks); @@ -204,14 +214,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} }; @@ -221,7 +238,7 @@ static dllhandle_t vf_dll = NULL; typedef struct { - qbyte *buffer; + unsigned char *buffer; ogg_int64_t ind, buffsize; } ov_decode_t; @@ -297,8 +314,9 @@ qboolean OGG_OpenLibrary (void) const char* dllnames_vo [] = { #if defined(WIN64) - "vorbis64.dll", + "libvorbis64.dll", #elif defined(WIN32) + "libvorbis.dll", "vorbis.dll", #elif defined(MACOSX) "libvorbis.dylib", @@ -311,8 +329,9 @@ qboolean OGG_OpenLibrary (void) const char* dllnames_vf [] = { #if defined(WIN64) - "vorbisfile64.dll", + "libvorbisfile64.dll", #elif defined(WIN32) + "libvorbisfile.dll", "vorbisfile.dll", #elif defined(MACOSX) "libvorbisfile.dylib", @@ -334,8 +353,8 @@ 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)) + 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"); @@ -370,17 +389,17 @@ 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))) +#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 qbyte resampling_buffer [48000 * 2 * 2]; +static unsigned char resampling_buffer [48000 * 2 * 2]; // Per-sfx data structure typedef struct { - qbyte *file; + unsigned char *file; size_t filesize; snd_format_t format; } ogg_stream_persfx_t; @@ -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,34 @@ 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 (channel_t* ch, 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; + snd_buffer_t* sb; int newlength, done, ret, bigendian; + unsigned int real_start; unsigned int factor; - size_t buff_len; - per_ch = ch->fetcher_data; + per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data; sfx = ch->sfx; - per_sfx = sfx->fetcher_data; - format = &sfx->format; - buff_len = STREAM_BUFFER_SIZE(format); + 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 memsize; - ogg_stream_persfx_t* per_sfx; + 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; - memsize = sizeof (*per_ch) - sizeof (per_ch->sb.data) + buff_len; - per_ch = Mem_Alloc (snd_mempool, memsize); + 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 = sfx->fetcher_data; // Open it with the VorbisFile API per_ch->ov_decode.buffer = per_sfx->file; @@ -440,56 +461,93 @@ static const sfxbuffer_t* OGG_FetchSound (channel_t* ch, unsigned int start, uns Mem_Free (per_ch); return NULL; } - - per_ch->sb.offset = 0; - per_ch->sb.length = 0; 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 (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)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; - 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) + if (sb->format.speed + 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 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 + if(newlength > sizeof(resampling_buffer)) + newlength = sizeof(resampling_buffer); // Decompress in the resampling_buffer #if BYTE_ORDER == BIG_ENDIAN @@ -501,10 +559,9 @@ static const sfxbuffer_t* OGG_FetchSound (channel_t* ch, unsigned int start, uns 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; + Snd_AppendToSndBuffer (sb, resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format); + *start = per_ch->sb_offset; return sb; } @@ -518,21 +575,19 @@ static void OGG_FetchEnd (channel_t* ch) { ogg_stream_perchannel_t* per_ch; - per_ch = ch->fetcher_data; + 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); + 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; - - format = &ch->sfx->format; - buff_len = STREAM_BUFFER_SIZE(format); - ch->sfx->memsize -= sizeof (*per_ch) - sizeof (per_ch->sb.data) + buff_len; } } @@ -544,7 +599,7 @@ OGG_FreeSfx */ static void OGG_FreeSfx (sfx_t* sfx) { - ogg_stream_persfx_t* per_sfx = sfx->fetcher_data; + ogg_stream_persfx_t* per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data; // Free the Ogg Vorbis file Mem_Free(per_sfx->file); @@ -558,7 +613,19 @@ static void OGG_FreeSfx (sfx_t* sfx) sfx->fetcher = NULL; } -static const snd_fetcher_t ogg_fetcher = { OGG_FetchSound, OGG_FetchEnd, OGG_FreeSfx }; + +/* +==================== +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 }; /* @@ -568,23 +635,26 @@ 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; + 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; if (!vf_dll) return false; // 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; @@ -593,7 +663,7 @@ qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *s) // 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 +676,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,30 +685,34 @@ 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) { ogg_stream_persfx_t* per_sfx; Con_DPrintf ("\"%s\" will be streamed\n", filename); - per_sfx = Mem_Alloc (snd_mempool, sizeof (*per_sfx)); - s->memsize += sizeof (*per_sfx); + 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 = 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)); + 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); + } } else { @@ -646,42 +720,51 @@ qboolean OGG_LoadVorbisFile (const char *filename, sfx_t *s) ogg_int64_t done; int bs, bigendian; 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); // Decode it - buff = Mem_Alloc (snd_mempool, (int)len); + buff = (char *)Mem_Alloc (snd_mempool, (int)len); done = 0; bs = 0; -#if BYTE_ORDER == LITTLE_ENDIAN - bigendian = 0; -#else +#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; - // 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 = 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->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); + } qov_clear (&vf); Mem_Free (data);