ogg.c File Reference

#include <errno.h>
#include "shared/shared.h"
#include "sound.h"
#include "client/sound/vorbis.h"
#include "stb_vorbis.c"

Go to the source code of this file.

Macros
#define	STB_VORBIS_NO_PUSHDATA_API

Enumerations
enum	{ MAX_NUM_OGGTRACKS = 32 }
enum	GameType { other, xatrix, rogue }

Functions
static int	getMappedGOGtrack (int track, enum GameType gameType)
void	OGG_InitTrackList (void)
static void	OGG_Read (void)
void	OGG_Stream (void)
void	OGG_PlayTrack (int trackNo)
static void	OGG_Info (void)
void	OGG_Stop (void)
static void	OGG_TogglePlayback (void)
void	OGG_HelpMsg (void)
void	OGG_Cmd (void)
void	OGG_SaveState (void)
void	OGG_RecoverState (void)
static void	ogg_enable_changed (cvar_t *self)
void	OGG_Init (void)
void	OGG_Shutdown (void)

Variables
static cvar_t *	ogg_shuffle
static cvar_t *	ogg_ignoretrack0
static cvar_t *	ogg_volume
static cvar_t *	ogg_enable
static int	ogg_curfile
static int	ogg_numbufs
static int	ogg_numsamples
static ogg_status_t	ogg_status
static stb_vorbis *	ogg_file
static qboolean	ogg_started
static char *	ogg_tracks [MAX_NUM_OGGTRACKS]
static int	ogg_maxfileindex
struct {
qboolean   saved
int   curfile
int   numsamples
}	ogg_saved_state

Macro Definition Documentation

STB_VORBIS_NO_PUSHDATA_API

#define STB_VORBIS_NO_PUSHDATA_API

Definition at line 43 of file ogg.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MAX_NUM_OGGTRACKS

Definition at line 57 of file ogg.c.

{ MAX_NUM_OGGTRACKS = 32 };

GameType

enum GameType

Enumerator
other
xatrix
rogue

Definition at line 62 of file ogg.c.

              {
    other, // incl. baseq2
    xatrix,
    rogue
};

Function Documentation

getMappedGOGtrack()

static int getMappedGOGtrack ( int  track, enum GameType  gameType  )

static

Definition at line 86 of file ogg.c.

{
    if(track <= 0)
        return 0;
 
    if(track == 1)
        return 0; // 1 is illegal (=> data track on CD), 0 means "no track"
 
    if(gameType == other)
        return track;
    if(gameType == rogue)
        return track + 10;
 
    // apparently it's xatrix => map the track to the corresponding TrackXX.ogg from GOG
    switch(track)
    {
        case  2: return 9;  // baseq2 9
        case  3: return 13; // rogue  3
        case  4: return 14; // rogue  4
        case  5: return 7;  // baseq2 6
        case  6: return 16; // rogue  6
        case  7: return 2;  // baseq2 2
        case  8: return 15; // rogue  5
        case  9: return 3;  // baseq2 3
        case 10: return 4;  // baseq2 4
        case 11: return 18; // rogue  8
        default:
            return track;
    }
}

Referenced by OGG_InitTrackList().

OGG_Cmd()

void OGG_Cmd

(

void

)

Definition at line 549 of file ogg.c.

{
    if (Cmd_Argc() < 2)
    {
        OGG_HelpMsg();
        return;
    }
 
    if (Q_stricmp(Cmd_Argv(1), "info") == 0)
    {
        OGG_Info();
    }
    else if (Q_stricmp(Cmd_Argv(1), "play") == 0)
    {
        if (Cmd_Argc() != 3)
        {
            Com_Printf("ogg play <track> : Play <track>");
            return;
        }
 
        int track = (int)strtol(Cmd_Argv(2), NULL, 10);
 
        if (track < 2 || track > ogg_maxfileindex)
        {
            Com_Printf("invalid track %s, must be an number between 2 and %d\n", Cmd_Argv(1), ogg_maxfileindex);
            return;
        }
        else
        {
            OGG_PlayTrack(track);
        }
    }
    else if (Q_stricmp(Cmd_Argv(1), "stop") == 0)
    {
        OGG_Stop();
    }
    else if (Q_stricmp(Cmd_Argv(1), "toggle") == 0)
    {
        OGG_TogglePlayback();
    }
    else
    {
        OGG_HelpMsg();
    }
}

Referenced by OGG_Init().

ogg_enable_changed()

static void ogg_enable_changed ( cvar_t *  self )

static

Definition at line 639 of file ogg.c.

{
    if (ogg_enable->integer && ogg_status == PAUSE || !ogg_enable->integer && ogg_status == PLAY)
    {
        OGG_TogglePlayback();
    }
}

Referenced by OGG_Init().

OGG_HelpMsg()

void OGG_HelpMsg

(

void

)

Definition at line 535 of file ogg.c.

{
    Com_Printf("Unknown sub command %s\n\n", Cmd_Argv(1));
    Com_Printf("Commands:\n");
    Com_Printf(" - info: Print information about playback state and tracks\n");
    Com_Printf(" - play <track>: Play track number <track>\n");
    Com_Printf(" - stop: Stop playback\n");
    Com_Printf(" - toggle: Toggle pause\n");
}

Referenced by OGG_Cmd().

OGG_Info()

static void OGG_Info ( void  )

static

Definition at line 438 of file ogg.c.

{
    Com_Printf("Tracks:\n");
    int numFiles = 0;
 
    for (int i = 2; i <= ogg_maxfileindex; i++)
    {
        if(ogg_tracks[i])
        {
            Com_Printf(" - %02d %s\n", i, ogg_tracks[i]);
            ++numFiles;
        }
        else
        {
            Com_Printf(" - %02d <none>\n", i);
        }
    }
 
    Com_Printf("Total: %d Ogg/Vorbis files.\n", ogg_maxfileindex+1);
 
    switch (ogg_status)
    {
        case PLAY:
            Com_Printf("State: Playing file %d (%s) at %i samples.\n",
                       ogg_curfile, ogg_tracks[ogg_curfile], stb_vorbis_get_sample_offset(ogg_file));
            break;
 
        case PAUSE:
            Com_Printf("State: Paused file %d (%s) at %i samples.\n",
                       ogg_curfile, ogg_tracks[ogg_curfile], stb_vorbis_get_sample_offset(ogg_file));
            break;
 
        case STOP:
            if (ogg_curfile == -1)
            {
                Com_Printf("State: Stopped.\n");
            }
            else
            {
                Com_Printf("State: Stopped file %d (%s).\n", ogg_curfile, ogg_tracks[ogg_curfile]);
            }
 
            break;
    }
}

Referenced by OGG_Cmd().

OGG_Init()

void OGG_Init

(

void

)

Definition at line 652 of file ogg.c.

{
    // Cvars
    ogg_shuffle = Cvar_Get("ogg_shuffle", "0", CVAR_ARCHIVE);
    ogg_ignoretrack0 = Cvar_Get("ogg_ignoretrack0", "0", CVAR_ARCHIVE);
    ogg_volume = Cvar_Get("ogg_volume", "1.0", CVAR_ARCHIVE);
    ogg_enable = Cvar_Get("ogg_enable", "1", CVAR_ARCHIVE);
    ogg_enable->changed = ogg_enable_changed;
 
    // Commands
    Cmd_AddCommand("ogg", OGG_Cmd);
 
    // Global variables
    ogg_curfile = -1;
    ogg_numsamples = 0;
    ogg_status = STOP;
 
    ogg_started = qtrue;
}

Referenced by S_Init().

OGG_InitTrackList()

void OGG_InitTrackList

(

void

)

Definition at line 121 of file ogg.c.

{
    for (int i=0; i<MAX_NUM_OGGTRACKS; ++i)
    {
        if (ogg_tracks[i] != NULL)
        {
            free(ogg_tracks[i]);
            ogg_tracks[i] = NULL;
        }
    }
 
    ogg_maxfileindex = 0;
 
    const char* potMusicDirs[3] = {0};
    char gameMusicDir[MAX_QPATH] = {0}; // e.g. "xatrix/music"
    cvar_t* gameCvar = Cvar_Get("game", "", CVAR_LATCH | CVAR_SERVERINFO);
 
    potMusicDirs[0] = "music/"; // $mod/music/
    potMusicDirs[1] = "../music/"; // global music dir (GOG)
    potMusicDirs[2] = "../" BASEGAME "/music/"; // baseq2/music/
 
    enum GameType gameType = other;
 
    if (strcmp("xatrix", gameCvar->string) == 0)
    {
        gameType = xatrix;
    }
    else if (strcmp("rogue", gameCvar->string) == 0)
    {
        gameType = rogue;
    }
 
    for (int potMusicDirIdx = 0; potMusicDirIdx < sizeof(potMusicDirs)/sizeof(potMusicDirs[0]); ++potMusicDirIdx)
    {
        const char* musicDir = potMusicDirs[potMusicDirIdx];
 
        if (musicDir == NULL)
        {
            break;
        }
 
        char fullMusicPath[MAX_OSPATH] = {0};
        snprintf(fullMusicPath, MAX_OSPATH, "%s/%s", fs_gamedir, musicDir);
 
        if(!Sys_IsDir(fullMusicPath))
        {
            continue;
        }
 
        char testFileName[MAX_OSPATH];
        char testFileName2[MAX_OSPATH];
 
        // the simple case (like before: $mod/music/02.ogg - 11.ogg or whatever)
        snprintf(testFileName, MAX_OSPATH, "%s02.ogg", fullMusicPath);
 
        if(Sys_IsFile(testFileName))
        {
            ogg_tracks[2] = strdup(testFileName);
 
            for(int i=3; i<MAX_NUM_OGGTRACKS; ++i)
            {
                snprintf(testFileName, MAX_OSPATH, "%s%02i.ogg", fullMusicPath, i);
 
                if(Sys_IsFile(testFileName))
                {
                    ogg_tracks[i] = strdup(testFileName);
                    ogg_maxfileindex = i;
                }
            }
 
            return;
        }
 
        // the GOG case: music/Track02.ogg to Track21.ogg
        int gogTrack = getMappedGOGtrack(8, gameType);
 
        snprintf(testFileName, MAX_OSPATH, "%sTrack%02i.ogg", fullMusicPath, gogTrack); // uppercase T
        snprintf(testFileName2, MAX_OSPATH, "%strack%02i.ogg", fullMusicPath, gogTrack); // lowercase t
 
        if(Sys_IsFile(testFileName) || Sys_IsFile(testFileName2))
        {
            for(int i=2; i<MAX_NUM_OGGTRACKS; ++i)
            {
                int gogTrack = getMappedGOGtrack(i, gameType);
 
                snprintf(testFileName, MAX_OSPATH, "%sTrack%02i.ogg", fullMusicPath, gogTrack); // uppercase T
                snprintf(testFileName2, MAX_OSPATH, "%strack%02i.ogg", fullMusicPath, gogTrack); // lowercase t
 
                if(Sys_IsFile(testFileName))
                {
                    ogg_tracks[i] = strdup(testFileName);
                    ogg_maxfileindex = i;
                }
                else if (Sys_IsFile(testFileName2))
                {
                    ogg_tracks[i] = strdup(testFileName2);
                    ogg_maxfileindex = i;
                }
            }
 
            return;
        }
    }
 
    // if tracks have been found above, we would've returned there
    Com_Printf("No Ogg Vorbis music tracks have been found, so there will be no music.\n");
}

Referenced by S_Init().

OGG_PlayTrack()

void OGG_PlayTrack

(

int

trackNo

)

Definition at line 323 of file ogg.c.

{
    if (s_started == SS_NOT)
        return;
 
    // Track 0 means "stop music".
    if(trackNo == 0)
    {
        if(ogg_ignoretrack0->value == 0)
        {
            OGG_Stop();
        }
 
        // Special case: If ogg_ignoretrack0 is 0 we stopped the music (see above)
        // and ogg_curfile is still holding the last track played (track >1). So
        // this triggers and we return. If ogg_ignoretrack is 1 we didn't stop the
        // music, as soon as the tracks ends OGG_Read() starts it over. Until here
        // everything's okay.
        // But if ogg_ignoretrack0 is 1, the game was just restarted and a save game
        // load send us trackNo 0, we would end up without music. Since we have no
        // way to get the last track before trackNo 0 was set just fall through and
        // shuffle a random track (see below).
        if (ogg_curfile > 0)
        {
            return;
        }
    }
 
    // Player has requested shuffle playback.
    if((trackNo == 0) || ogg_shuffle->value)
    {
        if(ogg_maxfileindex > 0)
        {
            trackNo = rand() % (ogg_maxfileindex+1);
            int retries = 100;
            while(ogg_tracks[trackNo] == NULL && retries-- > 0)
            {
                trackNo = rand() % (ogg_maxfileindex+1);
            }
        }
    }
 
    if(ogg_maxfileindex == 0)
    {
        return; // no ogg files at all, ignore this silently instead of printing warnings all the time
    }
 
    if ((trackNo < 2) || (trackNo > ogg_maxfileindex))
    {
        Com_Printf("OGG_PlayTrack: %d out of range.\n", trackNo);
        return;
    }
 
    if(ogg_tracks[trackNo] == NULL)
    {
        Com_Printf("OGG_PlayTrack: Don't have a .ogg file for track %d\n", trackNo);
    }
 
    /* Check running music. */
    if (ogg_status == PLAY)
    {
        if (ogg_curfile == trackNo)
        {
            return;
        }
        else
        {
            OGG_Stop();
        }
    }
 
    if (ogg_tracks[trackNo] == NULL)
    {
        Com_Printf("OGG_PlayTrack: I don't have a file for track %d!\n", trackNo);
 
        return;
    }
 
    /* Open ogg vorbis file. */
    FILE* f = fopen(ogg_tracks[trackNo], "rb");
 
    if (f == NULL)
    {
        Com_Printf("OGG_PlayTrack: could not open file %s for track %d: %s.\n", ogg_tracks[trackNo], trackNo, strerror(errno));
        ogg_tracks[trackNo] = NULL;
 
        return;
    }
 
    int res = 0;
    ogg_file = stb_vorbis_open_file(f, qtrue, &res, NULL);
 
    if (res != 0)
    {
        Com_Printf("OGG_PlayTrack: '%s' is not a valid Ogg Vorbis file (error %i).\n", ogg_tracks[trackNo], res);
        fclose(f);
 
        return;
    }
 
    /* Play file. */
    ogg_curfile = trackNo;
    ogg_numsamples = 0;
    if (ogg_enable->integer)
        ogg_status = PLAY;
    else
        ogg_status = PAUSE;
}

Referenced by CL_PrepRefresh(), OGG_Cmd(), OGG_Read(), and OGG_RecoverState().

OGG_Read()

static void OGG_Read ( void  )

static

Definition at line 235 of file ogg.c.

{
    short samples[4096] = {0};
 
    int read_samples = stb_vorbis_get_samples_short_interleaved(ogg_file, ogg_file->channels, samples,
        sizeof(samples) / ogg_file->channels);
 
    if (read_samples > 0)
    {
        ogg_numsamples += read_samples;
 
        S_RawSamples(read_samples, ogg_file->sample_rate, ogg_file->channels, ogg_file->channels,
            (byte *)samples, S_GetLinearVolume(ogg_volume->value));
    }
    else
    {
        // We cannot call OGG_Stop() here. It flushes the OpenAL sample
        // queue, thus about 12 seconds of music are lost. Instead we
        // just set the OGG state to stop and open a new file. The new
        // files content is added to the sample queue after the remaining
        // samples from the old file.
        stb_vorbis_close(ogg_file);
        ogg_status = STOP;
        ogg_numbufs = 0;
        ogg_numsamples = 0;
 
        OGG_PlayTrack(ogg_curfile);
    }
}

Referenced by OGG_Stream().

OGG_RecoverState()

void OGG_RecoverState

(

void

)

Definition at line 617 of file ogg.c.

{
    if (!ogg_saved_state.saved)
    {
        return;
    }
 
    // Mkay, ultra evil hack to recover the state in case of
    // shuffled playback. OGG_PlayTrack() does the shuffeling,
    // so switch it of before and enable after state recovery.
    int shuffle_state = ogg_shuffle->value;
    Cvar_SetValue(ogg_shuffle, 0, FROM_CODE);
 
    OGG_PlayTrack(ogg_saved_state.curfile);
    stb_vorbis_seek_frame(ogg_file, ogg_saved_state.numsamples);
    ogg_numsamples = ogg_saved_state.numsamples;
 
    Cvar_SetValue(ogg_shuffle, shuffle_state, FROM_CODE);
}

Referenced by S_Init().

OGG_SaveState()

void OGG_SaveState

(

void

)

Definition at line 599 of file ogg.c.

{
    if (ogg_status != PLAY)
    {
        ogg_saved_state.saved = qfalse;
 
        return;
    }
 
    ogg_saved_state.saved = qtrue;
    ogg_saved_state.curfile = ogg_curfile;
    ogg_saved_state.numsamples = ogg_numsamples;
}

Referenced by S_Shutdown().

OGG_Shutdown()

void OGG_Shutdown

(

void

)

Definition at line 676 of file ogg.c.

{
    if (!ogg_started)
    {
        return;
    }
 
    // Music must be stopped.
    OGG_Stop();
 
    // Free file lsit.
    for(int i=0; i<MAX_NUM_OGGTRACKS; ++i)
    {
        if(ogg_tracks[i] != NULL)
        {
            free(ogg_tracks[i]);
            ogg_tracks[i] = NULL;
        }
    }
    ogg_maxfileindex = 0;
 
    // Remove console commands
    Cmd_RemoveCommand("ogg");
 
    ogg_started = qfalse;
}

Referenced by S_Shutdown().

OGG_Stop()

void OGG_Stop

(

void

)

Definition at line 488 of file ogg.c.

{
    if (ogg_status == STOP)
    {
        return;
    }
 
#ifdef USE_OPENAL
    if (s_started == SS_OAL)
    {
        AL_UnqueueRawSamples();
    }
#endif
 
    stb_vorbis_close(ogg_file);
    ogg_status = STOP;
    ogg_numbufs = 0;
}

Referenced by OGG_Cmd(), OGG_PlayTrack(), OGG_Shutdown(), and SCR_PlayCinematic().

OGG_Stream()

void OGG_Stream

(

void

)

Definition at line 269 of file ogg.c.

{
    if (!ogg_started)
    {
        return;
    }
 
    if (ogg_status == PLAY)
    {
#ifdef USE_OPENAL
        if (s_started == SS_OAL)
        {
            /* Calculate the number of buffers used
               for storing decoded OGG/Vorbis data.
               We take the number of active buffers
               and add 256. 256 are about 12 seconds
               worth of sound, more than enough to
               be resilent against underruns. */
            if (ogg_numbufs == 0 || active_buffers < ogg_numbufs - 256)
            {
                ogg_numbufs = active_buffers + 256;
            }
 
            /* active_buffers are all active OpenAL buffers,
               buffering normal sfx _and_ ogg/vorbis samples. */
            while (active_buffers <= ogg_numbufs)
            {
                OGG_Read();
            }
        }
        else /* using SDL */
#endif
        {
            if (s_started == SS_DMA)
            {
                /* Read that number samples into the buffer, that
                   were played since the last call to this function.
                   This keeps the buffer at all times at an "optimal"
                   fill level. */
                while (paintedtime + S_MAX_RAW_SAMPLES - 2048 > s_rawend)
                {
                    OGG_Read();
                }
            }
        }
    }
}

Referenced by S_Update().

OGG_TogglePlayback()

static void OGG_TogglePlayback ( void  )

static

Definition at line 511 of file ogg.c.

{
    if (ogg_status == PLAY)
    {
        ogg_status = PAUSE;
        ogg_numbufs = 0;
 
#ifdef USE_OPENAL
        if (s_started == SS_OAL)
        {
            AL_UnqueueRawSamples();
        }
#endif
    }
    else if (ogg_status == PAUSE)
    {
        ogg_status = PLAY;
    }
}

Referenced by OGG_Cmd(), and ogg_enable_changed().

Variable Documentation

curfile

int curfile

Definition at line 70 of file ogg.c.

numsamples

int numsamples

Definition at line 71 of file ogg.c.

ogg_curfile

int ogg_curfile

static

Definition at line 50 of file ogg.c.

Referenced by OGG_Info(), OGG_Init(), OGG_PlayTrack(), OGG_Read(), and OGG_SaveState().

ogg_enable

cvar_t* ogg_enable

static

Definition at line 49 of file ogg.c.

Referenced by ogg_enable_changed(), OGG_Init(), and OGG_PlayTrack().

ogg_file

stb_vorbis* ogg_file

static

Definition at line 54 of file ogg.c.

Referenced by OGG_Info(), OGG_PlayTrack(), OGG_Read(), OGG_RecoverState(), and OGG_Stop().

ogg_ignoretrack0

cvar_t* ogg_ignoretrack0

static

Definition at line 47 of file ogg.c.

Referenced by OGG_Init(), and OGG_PlayTrack().

ogg_maxfileindex

int ogg_maxfileindex

static

Definition at line 59 of file ogg.c.

Referenced by OGG_Cmd(), OGG_Info(), OGG_InitTrackList(), OGG_PlayTrack(), and OGG_Shutdown().

ogg_numbufs

int ogg_numbufs

static

Definition at line 51 of file ogg.c.

Referenced by OGG_Read(), OGG_Stop(), OGG_Stream(), and OGG_TogglePlayback().

ogg_numsamples

int ogg_numsamples

static

Definition at line 52 of file ogg.c.

Referenced by OGG_Init(), OGG_PlayTrack(), OGG_Read(), OGG_RecoverState(), and OGG_SaveState().

ogg_saved_state

struct { ... } ogg_saved_state

Referenced by OGG_RecoverState(), and OGG_SaveState().

ogg_shuffle

cvar_t* ogg_shuffle

static

Definition at line 46 of file ogg.c.

Referenced by OGG_Init(), OGG_PlayTrack(), and OGG_RecoverState().

ogg_started

qboolean ogg_started

static

Definition at line 55 of file ogg.c.

Referenced by OGG_Init(), OGG_Shutdown(), and OGG_Stream().

ogg_status

ogg_status_t ogg_status

static

Definition at line 53 of file ogg.c.

Referenced by ogg_enable_changed(), OGG_Info(), OGG_Init(), OGG_PlayTrack(), OGG_Read(), OGG_SaveState(), OGG_Stop(), OGG_Stream(), and OGG_TogglePlayback().

ogg_tracks

char* ogg_tracks[MAX_NUM_OGGTRACKS]

static

Definition at line 58 of file ogg.c.

Referenced by OGG_Info(), OGG_InitTrackList(), OGG_PlayTrack(), and OGG_Shutdown().

ogg_volume

cvar_t* ogg_volume

static

Definition at line 48 of file ogg.c.

Referenced by OGG_Init(), and OGG_Read().

saved

qboolean saved

Definition at line 69 of file ogg.c.

Referenced by PutClientInServer().