int decoder_ogg_read( snd_stream_t *stream, int bytes, void *buffer ) { snd_ogg_stream_t *ogg_stream = (snd_ogg_stream_t *)stream->ptr; int bitstream, bytes_read, bytes_read_total = 0; int holes = 0; do { #ifdef ENDIAN_BIG bytes_read = qov_read( &ogg_stream->vorbisfile, (char *)buffer+bytes_read_total, bytes-bytes_read_total, 1, 2, 1, &bitstream ); #elif defined (ENDIAN_LITTLE) bytes_read = qov_read( &ogg_stream->vorbisfile, (char *)buffer+bytes_read_total, bytes-bytes_read_total, 0, 2, 1, &bitstream ); #else #error "runtime endianess detection support missing" #endif if( bytes_read < 0 ) { if( bytes_read == OV_HOLE ) { if( holes++ == 3 ) break; continue; } break; } bytes_read_total += bytes_read; } while( (bytes_read > 0 || bytes_read == OV_HOLE) && bytes_read_total < bytes ); return bytes_read_total; }
/* ==================== OGG_LoadVorbisFile Load an Ogg Vorbis file into memory ==================== */ qboolean OGG_LoadVorbisFile(const char *filename, sfx_t *sfx) { unsigned char *data; fs_offset_t filesize; ov_decode_t ov_decode; OggVorbis_File vf; vorbis_info *vi; vorbis_comment *vc; double peak, gaindb; #ifndef LINK_TO_LIBVORBIS if (!vf_dll) return false; #endif // Return if already loaded if (sfx->fetcher != NULL) return true; // Load the file completely data = FS_LoadFile(filename, snd_mempool, false, &filesize); if (data == NULL) return false; 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) { 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); if (vi->channels < 1 || vi->channels > 2) { Con_Printf("%s has an unsupported number of channels (%i)\n", sfx->name, vi->channels); qov_clear (&vf); Mem_Free(data); return false; } sfx->format.speed = vi->rate; sfx->format.channels = vi->channels; sfx->format.width = 2; // We always work with 16 bits samples 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; 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; sfx->fetcher_data = per_sfx; sfx->fetcher = &ogg_fetcher; sfx->flags |= SFXFLAG_STREAMED; vc = qov_comment(&vf, -1); 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; long ret; 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; while ((ret = qov_read(&vf, &buff[done], (int)(len - done), mem_bigendian, 2, 1, &bs)) > 0) done += ret; vc = qov_comment(&vf, -1); OGG_DecodeTags(vc, &sfx->loopstart, &sfx->total_length, sfx->total_length, &peak, &gaindb); qov_clear(&vf); Mem_Free(data); } 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; }
/* ==================== OGG_GetSamplesFloat ==================== */ static void OGG_GetSamplesFloat (channel_t *ch, sfx_t *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat) { 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) { // 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) { // this never happens - this function succeeded earlier on the same data Mem_Free(per_ch); return; } per_ch->bs = 0; per_ch->buffer_firstframe = 0; per_ch->buffer_numframes = 0; // attach the struct to our channel ch->fetcher_data = (void *)per_ch; } // if the request is too large for our buffer, loop... while (numsampleframes * f > (int)sizeof(per_ch->buffer)) { done = sizeof(per_ch->buffer) / f; OGG_GetSamplesFloat(ch, sfx, firstsampleframe, done, outsamplesfloat); firstsampleframe += done; numsampleframes -= done; outsamplesfloat += done * sfx->format.channels; } // 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) { // 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) { // LordHavoc: we can't Con_Printf here, not thread safe... //Con_Printf("OGG_FetchSound: qov_pcm_seek(..., %d) returned %d\n", firstsampleframe, ret); return; } } // decompress the file as needed if (firstsampleframe + numsampleframes > per_ch->buffer_firstframe + per_ch->buffer_numframes) { // 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; } // 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); }
sfxcache_t *S_LoadSound(sfx_t *s) { char namebuffer[MAX_OSPATH]; char extionless[MAX_OSPATH]; sfxcache_t *sc = NULL; int eof = 0; int current_section; vfsfile_t *f; OggVorbis_File oggfile; vorbis_info *ogginfo; ov_callbacks ovc = { vorbis_callback_read, vorbis_callback_seek, vorbis_callback_close, vorbis_callback_tell }; static char pcmbuff[4096]; //unsigned char *data; wavinfo_t info; int len; //int filesize; // see if still in memory if ((sc = (sfxcache_t *) Cache_Check (&s->cache))) return sc; if (!vorbis_CheckActive()) vorbis_LoadLibrary(); // load it in COM_StripExtension(s->name, extionless); snprintf (namebuffer, sizeof (namebuffer), "sound/%s.ogg", extionless); /* if (!(data = FS_LoadTempFile (namebuffer, &filesize))) { Com_Printf ("Couldn't load %s\n", namebuffer); return NULL; }*/ if (!(f = FS_OpenVFS(namebuffer, "rb", FS_ANY))) { Com_Printf("Couldn't load %s\n", namebuffer); return NULL; } if (qov_open_callbacks(f, &oggfile, NULL, 0, ovc)) { Com_Printf("Invalid sound file %s\n", namebuffer); VFS_CLOSE(f); return NULL; } if (!(ogginfo = qov_info(&oggfile,-1))) { Com_Printf("Unable to retrieve information for %s\n", namebuffer); goto fail; } /* Print some information */ fprintf(stderr, "%s\n", namebuffer); { char **ptr = qov_comment(&oggfile,-1)->user_comments; while(*ptr){ fprintf(stderr,"%s\n",*ptr); ++ptr; } fprintf(stderr,"\nBitstream is %d channel, %ldHz\n", ogginfo->channels, ogginfo->rate); fprintf(stderr,"\nDecoded length: %ld samples\n", (long) qov_pcm_total(&oggfile,-1)); fprintf(stderr,"Encoded by: %s\n\n", qov_comment(&oggfile,-1)->vendor); } info.rate = ogginfo->rate; // Frequency rate info.width = 1; // 8 bit samples info.channels = ogginfo->channels; // 1 == mono, 2 == stereo info.loopstart = -1; // NOOO idea... info.samples = qov_pcm_total(&oggfile,-1); // Total samples info.dataofs = 0; // offset //FMod_CheckModel(namebuffer, data, filesize); //info = GetWavinfo (s->name, data, filesize); // Stereo sounds are allowed (intended for music) if (info.channels < 1 || info.channels > 2) { Com_Printf("%s has an unsupported number of channels (%i)\n",s->name, info.channels); return NULL; } len = (int) ((double) info.samples * (double) shm->format.speed / (double) info.rate); len = len * info.width * info.channels; if (!(sc = (sfxcache_t *) Cache_Alloc (&s->cache, len + sizeof(sfxcache_t), s->name))) return NULL; /* Read the whole Ogg Vorbis file in */ byte *output = sc->data; while (!eof) { // 0 == little endian, 1 = big endian // 1 == 8 bit samples, 2 = 16 bit samples // 1 == signed samples long ret = qov_read(&oggfile, pcmbuff, sizeof(pcmbuff), 0, info.width, 1, ¤t_section); if (ret == 0) { eof = 1; } else if (ret < 0) { /* error in the stream. Not a problem, just reporting it in * case we (the app) cares. In this case, we don't. */ } else { /* we don't bother dealing with sample rate changes, etc, but * you'll have to */ memcpy(output, pcmbuff, ret); output += ret; } } qov_clear(&oggfile); sc->total_length = (unsigned int) info.samples; sc->format.speed = info.rate; sc->format.width = info.width; sc->format.channels = info.channels; if (info.loopstart < 0) sc->loopstart = -1; else sc->loopstart = (int)((double)info.loopstart * (double)shm->format.speed / (double)sc->format.speed); // ResampleSfx (s, data + info.dataofs, info.samples, &sc->format, sc->data); return sc; fail: qov_clear(&oggfile); // Only goto fail if ov_open* succeded if (f) { VFS_CLOSE(f); } return NULL; }
void *decoder_ogg_load( const char *filename, snd_info_t *info ) { OggVorbis_File vorbisfile; int filenum, bitstream, bytes_read, bytes_read_total; char *buffer; ov_callbacks callbacks = { ovcb_read, ovcb_seek, ovcb_close, ovcb_tell }; trap_FS_FOpenFile( filename, &filenum, FS_READ|FS_NOSIZE ); if( !filenum ) return NULL; if( trap_FS_IsUrl( filename ) ) { callbacks.seek_func = NULL; callbacks.tell_func = NULL; } qov_open_callbacks( (void *) (qintptr) filenum, &vorbisfile, NULL, 0, callbacks ); if( callbacks.seek_func && !qov_seekable( &vorbisfile ) ) { Com_Printf( "Error unsupported .ogg file (not seekable): %s\n", filename ); qov_clear( &vorbisfile ); // Does FS_FCloseFile return NULL; } if( qov_streams( &vorbisfile ) != 1 ) { Com_Printf( "Error unsupported .ogg file (multiple logical bitstreams): %s\n", filename ); qov_clear( &vorbisfile ); // Does FS_FCloseFile return NULL; } if( !read_ogg_header( vorbisfile, info ) ) { Com_Printf( "Error reading .ogg file header: %s\n", filename ); qov_clear( &vorbisfile ); // Does FS_FCloseFile return NULL; } buffer = S_Malloc( info->size ); bytes_read_total = 0; do { #ifdef ENDIAN_BIG bytes_read = qov_read( &vorbisfile, buffer+bytes_read_total, info->size-bytes_read_total, 1, 2, 1, &bitstream ); #elif defined (ENDIAN_LITTLE) bytes_read = qov_read( &vorbisfile, buffer+bytes_read_total, info->size-bytes_read_total, 0, 2, 1, &bitstream ); #else #error "runtime endianess detection support missing" #endif bytes_read_total += bytes_read; } while( bytes_read > 0 && bytes_read_total < info->size ); qov_clear( &vorbisfile ); // Does FS_FCloseFile if( !bytes_read_total ) { Com_Printf( "Error reading .ogg file: %s\n", filename ); S_Free( buffer ); return NULL; } return buffer; }