snd_ogg.c File Reference

#include "darkplaces.h"
#include "snd_main.h"
#include "snd_ogg.h"
#include "snd_wav.h"
#include "sound.h"

Include dependency graph for snd_ogg.c:

Go to the source code of this file.

Data Structures
struct	ogg_stream_perchannel_t
struct	ogg_stream_persfx_t
struct	ogg_stream_state
struct	ogg_sync_state
struct	oggpack_buffer
struct	OggVorbis_File
struct	ov_callbacks
struct	ov_decode_t
struct	vorbis_block
struct	vorbis_comment
struct	vorbis_dsp_state
struct	vorbis_info

Functions
void	OGG_CloseLibrary (void)
static void	OGG_DecodeTags (vorbis_comment *vc, unsigned int *start, unsigned int *length, unsigned int numsamples, double *peak, double *gaindb)
static void	OGG_FreeSfx (sfx_t *sfx)
static void	OGG_GetSamplesFloat (channel_t *ch, sfx_t *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat)
qbool	OGG_LoadVorbisFile (const char *filename, sfx_t *sfx)
qbool	OGG_OpenLibrary (void)
static void	OGG_StopChannel (channel_t *ch)
static int	ovcb_close (void *ov_decode)
static size_t	ovcb_read (void *ptr, size_t size, size_t nb, void *datasource)
static int	ovcb_seek (void *datasource, int64_t offset, int whence)
static long	ovcb_tell (void *ov_decode)

Variables
static const ov_callbacks	callbacks = {ovcb_read, ovcb_seek, ovcb_close, ovcb_tell}
static const snd_fetcher_t	ogg_fetcher = {OGG_GetSamplesFloat, OGG_StopChannel, OGG_FreeSfx}
static int(*	qov_clear )(OggVorbis_File *vf)
static vorbis_comment *(*	qov_comment )(OggVorbis_File *vf, int link)
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, int64_t pos)
static 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 char *(*	qvorbis_comment_query )(vorbis_comment *vc, const char *tag, int count)
static dllhandle_t	vf_dll = NULL
static dllhandle_t	vo_dll = NULL
static dllfunction_t	vorbisfilefuncs []
static dllfunction_t	vorbisfuncs []

Function Documentation

OGG_CloseLibrary()

void OGG_CloseLibrary

(

void

)

Definition at line 320 of file snd_ogg.c.

{
    Sys_FreeLibrary (&vf_dll);
    Sys_FreeLibrary (&vo_dll);
}

References Sys_FreeLibrary(), vf_dll, and vo_dll.

Referenced by S_Terminate().

OGG_DecodeTags()

static void OGG_DecodeTags ( vorbis_comment * vc, unsigned int * start, unsigned int * length, unsigned int numsamples, double * peak, double * gaindb )

static

Definition at line 540 of file snd_ogg.c.

{
    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), numsamples);
        if(endcomment)
            *length = (unsigned int) bound(0, atof(endcomment), numsamples);
        else if(lengthcomment)
            *length = (unsigned int) bound(0, *start + atof(lengthcomment), numsamples);
    }
}

References bound, int(), length, NULL, and qvorbis_comment_query.

Referenced by OGG_LoadVorbisFile().

OGG_FreeSfx()

static void OGG_FreeSfx ( sfx_t * sfx )

static

Definition at line 528 of file snd_ogg.c.

{
    ogg_stream_persfx_t *per_sfx = (ogg_stream_persfx_t *)sfx->fetcher_data;
    // free the complete file we were keeping around
    Mem_Free(per_sfx->file);
    // free the file information structure
    Mem_Free(per_sfx);
}

References ogg_stream_persfx_t::file, and Mem_Free.

OGG_GetSamplesFloat()

static void OGG_GetSamplesFloat ( channel_t * ch, sfx_t * sfx, int firstsampleframe, int numsampleframes, float * outsamplesfloat )

static

Definition at line 418 of file snd_ogg.c.

{
    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, (int64_t)firstsampleframe);
        if (ret != 0)
        {
            // LadyHavoc: 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);
}

References ogg_stream_perchannel_t::bs, buf, ogg_stream_perchannel_t::buffer, ov_decode_t::buffer, ogg_stream_perchannel_t::buffer_firstframe, ogg_stream_perchannel_t::buffer_numframes, ov_decode_t::buffsize, callbacks, f, channel_t::fetcher_data, ogg_stream_persfx_t::file, ogg_stream_persfx_t::filesize, i, ov_decode_t::ind, Mem_Alloc, mem_bigendian, Mem_Free, NULL, offset, OGG_GetSamplesFloat(), ogg_stream_perchannel_t::ov_decode, qov_open_callbacks, qov_pcm_seek, qov_read, ret, snd_mempool, and ogg_stream_perchannel_t::vf.

Referenced by OGG_GetSamplesFloat().

OGG_LoadVorbisFile()

qbool OGG_LoadVorbisFile	(	const char *	filename,
		sfx_t *	sfx )

Definition at line 598 of file snd_ogg.c.

{
    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;
        int64_t len;
        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;
}

References ov_decode_t::buffer, ov_decode_t::buffsize, callbacks, vorbis_info::channels, Con_Printf(), data, developer_loading, ogg_stream_persfx_t::file, ogg_stream_persfx_t::filesize, FS_LoadFile(), ov_decode_t::ind, cvar_t::integer, log(), max, Mem_Alloc, mem_bigendian, Mem_Free, min, NULL, OGG_DecodeTags(), ogg_fetcher, qov_clear, qov_comment, qov_info, qov_open_callbacks, qov_pcm_total, qov_read, vorbis_info::rate, ret, SFXFLAG_STREAMED, snd_mempool, snd_streaming, snd_streaming_length, cvar_t::value, vf_dll, and wav_fetcher.

Referenced by S_LoadSound().

OGG_OpenLibrary()

qbool OGG_OpenLibrary

(

void

)

Definition at line 267 of file snd_ogg.c.

{
    const char* dllnames_vo [] =
    {
#if defined(WIN32)
        "libvorbis-0.dll",
        "libvorbis.dll",
        "vorbis.dll",
#elif defined(MACOSX)
        "libvorbis.dylib",
#else
        "libvorbis.so.0",
        "libvorbis.so",
#endif
        NULL
    };
    const char* dllnames_vf [] =
    {
#if defined(WIN32)
        "libvorbisfile-3.dll",
        "libvorbisfile.dll",
        "vorbisfile.dll",
#elif defined(MACOSX)
        "libvorbisfile.dylib",
#else
        "libvorbisfile.so.3",
        "libvorbisfile.so",
#endif
        NULL
    };
 
    // Already loaded?
    if (vf_dll)
        return true;
 
// COMMANDLINEOPTION: Sound: -novorbis disables ogg vorbis sound support
    if (Sys_CheckParm("-novorbis"))
        return false;
 
    // 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
    return Sys_LoadDependency (dllnames_vo, &vo_dll, vorbisfuncs) && Sys_LoadDependency (dllnames_vf, &vf_dll, vorbisfilefuncs);
}

References NULL, Sys_CheckParm(), Sys_LoadDependency(), vf_dll, vo_dll, vorbisfilefuncs, and vorbisfuncs.

Referenced by S_Init().

OGG_StopChannel()

static void OGG_StopChannel ( channel_t * ch )

static

Definition at line 511 of file snd_ogg.c.

{
    ogg_stream_perchannel_t *per_ch = (ogg_stream_perchannel_t *)ch->fetcher_data;
    if (per_ch != NULL)
    {
        // release the vorbis decompressor
        qov_clear(&per_ch->vf);
        Mem_Free(per_ch);
    }
}

References channel_t::fetcher_data, Mem_Free, NULL, qov_clear, and ogg_stream_perchannel_t::vf.

ovcb_close()

static int ovcb_close ( void * ov_decode )

static

Definition at line 382 of file snd_ogg.c.

{
    return 0;
}

ovcb_read()

static size_t ovcb_read ( void * ptr, size_t size, size_t nb, void * datasource )

static

Definition at line 342 of file snd_ogg.c.

{
    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;
}

References ov_decode_t::buffer, ov_decode_t::buffsize, ov_decode_t::ind, and size.

ovcb_seek()

static int ovcb_seek ( void * datasource, int64_t offset, int whence )

static

Definition at line 358 of file snd_ogg.c.

{
    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;
}

References ov_decode_t::buffsize, ov_decode_t::ind, and offset.

ovcb_tell()

static long ovcb_tell ( void * ov_decode )

static

Definition at line 387 of file snd_ogg.c.

{
    return ((ov_decode_t*)ov_decode)->ind;
}

Variable Documentation

callbacks

const ov_callbacks callbacks = {ovcb_read, ovcb_seek, ovcb_close, ovcb_tell}

static

Definition at line 411 of file snd_ogg.c.

{ovcb_read, ovcb_seek, ovcb_close, ovcb_tell};

Referenced by OGG_GetSamplesFloat(), and OGG_LoadVorbisFile().

ogg_fetcher

const snd_fetcher_t ogg_fetcher = {OGG_GetSamplesFloat, OGG_StopChannel, OGG_FreeSfx}

static

Definition at line 538 of file snd_ogg.c.

{OGG_GetSamplesFloat, OGG_StopChannel, OGG_FreeSfx};

Referenced by OGG_LoadVorbisFile().

qov_clear

int(* qov_clear) (OggVorbis_File *vf) ( OggVorbis_File * vf )

static

Definition at line 217 of file snd_ogg.c.

Referenced by OGG_LoadVorbisFile(), and OGG_StopChannel().

qov_comment

vorbis_comment *(* qov_comment) (OggVorbis_File *vf, int link) ( OggVorbis_File * vf, int link )

static

Definition at line 219 of file snd_ogg.c.

Referenced by OGG_LoadVorbisFile().

qov_info

vorbis_info *(* qov_info) (OggVorbis_File *vf, int link) ( OggVorbis_File * vf, int link )

static

Definition at line 218 of file snd_ogg.c.

Referenced by OGG_LoadVorbisFile().

qov_open_callbacks

int(* qov_open_callbacks) (void *datasource, OggVorbis_File *vf, char *initial, long ibytes, ov_callbacks callbacks) ( void * datasource, OggVorbis_File * vf, char * initial, long ibytes, ov_callbacks callbacks )

static

Definition at line 221 of file snd_ogg.c.

Referenced by OGG_GetSamplesFloat(), and OGG_LoadVorbisFile().

qov_pcm_seek

int(* qov_pcm_seek) (OggVorbis_File *vf, int64_t pos) ( OggVorbis_File * vf, int64_t pos )

static

Definition at line 224 of file snd_ogg.c.

Referenced by OGG_GetSamplesFloat().

qov_pcm_total

int64_t(* qov_pcm_total) (OggVorbis_File *vf, int i) ( OggVorbis_File * vf, int i )

static

Definition at line 225 of file snd_ogg.c.

Referenced by OGG_LoadVorbisFile().

qov_read

long(* qov_read) (OggVorbis_File *vf, char *buffer, int length, int bigendianp, int word, int sgned, int *bitstream) ( OggVorbis_File * vf, char * buffer, int length, int bigendianp, int word, int sgned, int * bitstream )

static

Definition at line 226 of file snd_ogg.c.

Referenced by OGG_GetSamplesFloat(), and OGG_LoadVorbisFile().

qvorbis_comment_query

char *(* qvorbis_comment_query) (vorbis_comment *vc, const char *tag, int count) ( vorbis_comment * vc, const char * tag, int count )

static

Definition at line 220 of file snd_ogg.c.

Referenced by OGG_DecodeTags().

vf_dll

dllhandle_t vf_dll = NULL

static

Definition at line 249 of file snd_ogg.c.

Referenced by OGG_CloseLibrary(), OGG_LoadVorbisFile(), and OGG_OpenLibrary().

vo_dll

dllhandle_t vo_dll = NULL

static

Definition at line 248 of file snd_ogg.c.

Referenced by OGG_CloseLibrary(), and OGG_OpenLibrary().

vorbisfilefuncs

dllfunction_t vorbisfilefuncs[]

static

Initial value:

=
{
    {"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}
}

Definition at line 229 of file snd_ogg.c.

{
    {"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}
};

Referenced by OGG_OpenLibrary().

vorbisfuncs

dllfunction_t vorbisfuncs[]

static

Initial value:

=
{
    {"vorbis_comment_query",    (void **) &qvorbis_comment_query},
    {NULL, NULL}
}

Definition at line 241 of file snd_ogg.c.

{
    {"vorbis_comment_query",    (void **) &qvorbis_comment_query},
    {NULL, NULL}
};

Referenced by OGG_OpenLibrary().