cl_demo.c File Reference

#include "quakedef.h"

Include dependency graph for cl_demo.c:

Go to the source code of this file.

Data Structures
struct	benchmarkhistory_t

Macros
#define	DO_MAX(f)
#define	DO_MED(f)
#define	DO_MIN(f)

Functions
void	CL_CutDemo (unsigned char **buf, fs_offset_t *filesize)
void	CL_Demo_Init (void)
static void	CL_Demos_f (cmd_state_t *cmd)
static void	CL_FinishTimeDemo (void)
void	CL_NextDemo (void)
void	CL_PasteDemo (unsigned char **buf, fs_offset_t *filesize)
static void	CL_PauseDemo_f (cmd_state_t *cmd)
void	CL_PlayDemo (const char *demo)
void	CL_PlayDemo_f (cmd_state_t *cmd)
void	CL_ReadDemoMessage (void)
void	CL_Record_f (cmd_state_t *cmd)
static void	CL_Startdemos_f (cmd_state_t *cmd)
void	CL_Stop_f (cmd_state_t *cmd)
static void	CL_Stopdemo_f (cmd_state_t *cmd)
void	CL_StopPlayback (void)
void	CL_TimeDemo_f (cmd_state_t *cmd)
void	CL_WriteDemoMessage (sizebuf_t *message)
static int	doublecmp_withoffset (const void *a_, const void *b_)

Variables
static size_t	doublecmp_offset

Macro Definition Documentation

DO_MAX

#define DO_MAX

(

f

)

Value:

                    for(i = first; i < benchmark_runs; ++i) if((i == first) || (history[i].f > f)) f = history[i].f

Referenced by CL_FinishTimeDemo().

DO_MED

#define DO_MED

(

f

)

Value:

                    doublecmp_offset = (char *)&history->f - (char *)history; \
                    qsort(history + first, benchmark_runs - first, sizeof(*history), doublecmp_withoffset); \
                    if((first + benchmark_runs) & 1) \
                        f = history[(first + benchmark_runs - 1) / 2].f; \
                    else \
                        f = (history[(first + benchmark_runs - 2) / 2].f + history[(first + benchmark_runs) / 2].f) / 2

Referenced by CL_FinishTimeDemo().

DO_MIN

#define DO_MIN

(

f

)

Value:

                    for(i = first; i < benchmark_runs; ++i) if((i == first) || (history[i].f < f)) f = history[i].f

Referenced by CL_FinishTimeDemo().

Function Documentation

CL_CutDemo()

void CL_CutDemo	(	unsigned char **	buf,
		fs_offset_t *	filesize )

Definition at line 137 of file cl_demo.c.

{
    *buf = NULL;
    *filesize = 0;
 
    FS_Close(cls.demofile);
    *buf = FS_LoadFile(cls.demoname, tempmempool, false, filesize);
 
    // restart the demo recording
    cls.demofile = FS_OpenRealFile(cls.demoname, "wb", false);
    if(!cls.demofile)
        Sys_Error("failed to reopen the demo file");
    FS_Printf(cls.demofile, "%i\n", cls.forcetrack);
}

References buf, cls, FS_Close(), FS_LoadFile(), FS_OpenRealFile(), FS_Printf(), NULL, Sys_Error(), and tempmempool.

Referenced by CL_VM_Init().

CL_Demo_Init()

void CL_Demo_Init

(

void

)

Definition at line 737 of file cl_demo.c.

{
    Cmd_AddCommand(CF_CLIENT, "record", CL_Record_f, "record a demo");
    Cmd_AddCommand(CF_CLIENT, "stop", CL_Stop_f, "stop recording or playing a demo");
    Cmd_AddCommand(CF_CLIENT, "playdemo", CL_PlayDemo_f, "watch a demo file");
    Cmd_AddCommand(CF_CLIENT, "timedemo", CL_TimeDemo_f, "play back a demo as fast as possible and save statistics to benchmark.log");
    Cmd_AddCommand(CF_CLIENT, "startdemos", CL_Startdemos_f, "start playing back the selected demos sequentially (used at end of startup script)");
    Cmd_AddCommand(CF_CLIENT, "demos", CL_Demos_f, "restart looping demos defined by the last startdemos command");
    Cmd_AddCommand(CF_CLIENT, "stopdemo", CL_Stopdemo_f, "stop playing or recording demo (like stop command) and return to looping demos");
    // LadyHavoc: added pausedemo
    Cmd_AddCommand(CF_CLIENT, "pausedemo", CL_PauseDemo_f, "pause demo playback (can also safely pause demo recording if using QUAKE, QUAKEDP or NEHAHRAMOVIE protocol, useful for making movies)");
    Cvar_RegisterVariable (&cl_autodemo);
    Cvar_RegisterVariable (&cl_autodemo_nameformat);
    Cvar_RegisterVariable (&cl_autodemo_delete);
    Cvar_RegisterVariable (&cl_startdemos);
}

References CF_CLIENT, cl_autodemo, cl_autodemo_delete, cl_autodemo_nameformat, CL_Demos_f(), CL_PauseDemo_f(), CL_PlayDemo_f(), CL_Record_f(), cl_startdemos, CL_Startdemos_f(), CL_Stop_f(), CL_Stopdemo_f(), CL_TimeDemo_f(), Cmd_AddCommand(), and Cvar_RegisterVariable().

Referenced by CL_Init().

CL_Demos_f()

void CL_Demos_f ( cmd_state_t * cmd )

static

Definition at line 703 of file cl_demo.c.

{
    if (cls.state == ca_dedicated)
        return;
    if (cls.demonum == -1)
        cls.demonum = 1;
    CL_Disconnect();
    CL_NextDemo();
}

References ca_dedicated, CL_Disconnect(), CL_NextDemo(), cls, and cmd().

Referenced by CL_Demo_Init().

CL_FinishTimeDemo()

void CL_FinishTimeDemo ( void )

static

Definition at line 504 of file cl_demo.c.

{
    int frames;
    int i;
    double time, totalfpsavg;
    double fpsmin, fpsavg, fpsmax; // report min/avg/max fps
    static int benchmark_runs = 0;
    char vabuf[1024];
 
    cls.timedemo = host.restless = false;
 
    frames = cls.td_frames;
    time = host.realtime - cls.td_starttime;
    totalfpsavg = time > 0 ? frames / time : 0;
    fpsmin = cls.td_onesecondminfps;
    fpsavg = cls.td_onesecondavgcount ? cls.td_onesecondavgfps / cls.td_onesecondavgcount : 0;
    fpsmax = cls.td_onesecondmaxfps;
    // LadyHavoc: timedemo now prints out 7 digits of fraction, and min/avg/max
    Con_Printf("%i frames %5.7f seconds %5.7f fps, one-second fps min/avg/max: %.0f %.0f %.0f (%i seconds)\n", frames, time, totalfpsavg, fpsmin, fpsavg, fpsmax, cls.td_onesecondavgcount);
    Sys_TimeString(vabuf, sizeof(vabuf), "%Y-%m-%d %H:%M:%S");
    Log_Printf("benchmark.log", "date %s | enginedate %s | demo %s | commandline %s | run %d | result %i frames %5.7f seconds %5.7f fps, one-second fps min/avg/max: %.0f %.0f %.0f (%i seconds)\n", vabuf, engineversion, cls.demoname, cmdline.string, benchmark_runs + 1, frames, time, totalfpsavg, fpsmin, fpsavg, fpsmax, cls.td_onesecondavgcount);
    if (Sys_CheckParm("-benchmark"))
    {
        ++benchmark_runs;
        i = Sys_CheckParm("-benchmarkruns");
        if(i && i + 1 < sys.argc)
        {
            static benchmarkhistory_t *history = NULL;
            if(!history)
                history = (benchmarkhistory_t *)Z_Malloc(sizeof(*history) * atoi(sys.argv[i + 1]));
 
            history[benchmark_runs - 1].frames = frames;
            history[benchmark_runs - 1].time = time;
            history[benchmark_runs - 1].totalfpsavg = totalfpsavg;
            history[benchmark_runs - 1].fpsmin = fpsmin;
            history[benchmark_runs - 1].fpsavg = fpsavg;
            history[benchmark_runs - 1].fpsmax = fpsmax;
 
            if(atoi(sys.argv[i + 1]) > benchmark_runs)
            {
                // restart the benchmark
                Cbuf_AddText(cmd_local, va(vabuf, sizeof(vabuf), "timedemo %s\n", cls.demoname));
                // cannot execute here
            }
            else
            {
                // print statistics
                int first = Sys_CheckParm("-benchmarkruns_skipfirst") ? 1 : 0;
                if(benchmark_runs > first)
                {
#define DO_MIN(f) \
                    for(i = first; i < benchmark_runs; ++i) if((i == first) || (history[i].f < f)) f = history[i].f
 
#define DO_MAX(f) \
                    for(i = first; i < benchmark_runs; ++i) if((i == first) || (history[i].f > f)) f = history[i].f
 
#define DO_MED(f) \
                    doublecmp_offset = (char *)&history->f - (char *)history; \
                    qsort(history + first, benchmark_runs - first, sizeof(*history), doublecmp_withoffset); \
                    if((first + benchmark_runs) & 1) \
                        f = history[(first + benchmark_runs - 1) / 2].f; \
                    else \
                        f = (history[(first + benchmark_runs - 2) / 2].f + history[(first + benchmark_runs) / 2].f) / 2
 
                    DO_MIN(frames);
                    DO_MAX(time);
                    DO_MIN(totalfpsavg);
                    DO_MIN(fpsmin);
                    DO_MIN(fpsavg);
                    DO_MIN(fpsmax);
                    Con_Printf("MIN: %i frames %5.7f seconds %5.7f fps, one-second fps min/avg/max: %.0f %.0f %.0f (%i seconds)\n", frames, time, totalfpsavg, fpsmin, fpsavg, fpsmax, cls.td_onesecondavgcount);
 
                    DO_MED(frames);
                    DO_MED(time);
                    DO_MED(totalfpsavg);
                    DO_MED(fpsmin);
                    DO_MED(fpsavg);
                    DO_MED(fpsmax);
                    Con_Printf("MED: %i frames %5.7f seconds %5.7f fps, one-second fps min/avg/max: %.0f %.0f %.0f (%i seconds)\n", frames, time, totalfpsavg, fpsmin, fpsavg, fpsmax, cls.td_onesecondavgcount);
 
                    DO_MAX(frames);
                    DO_MIN(time);
                    DO_MAX(totalfpsavg);
                    DO_MAX(fpsmin);
                    DO_MAX(fpsavg);
                    DO_MAX(fpsmax);
                    Con_Printf("MAX: %i frames %5.7f seconds %5.7f fps, one-second fps min/avg/max: %.0f %.0f %.0f (%i seconds)\n", frames, time, totalfpsavg, fpsmin, fpsavg, fpsmax, cls.td_onesecondavgcount);
                }
                Z_Free(history);
                history = NULL;
                host.state = host_shutdown;
            }
        }
        else
            host.state = host_shutdown;
    }
 
    // Might need to re-enable vsync
    Cvar_Callback(&vid_vsync);
}

References Cbuf_AddText(), cls, cmd_local, cmdline, Con_Printf(), Cvar_Callback(), DO_MAX, DO_MED, DO_MIN, engineversion, first, history, host, host_shutdown, Log_Printf(), NULL, sys, Sys_CheckParm(), Sys_TimeString(), time, va(), vid_vsync, Z_Free, and Z_Malloc.

Referenced by CL_StopPlayback().

CL_NextDemo()

void CL_NextDemo

(

void

)

Definition at line 50 of file cl_demo.c.

{
    char    str[MAX_INPUTLINE];
 
    if (cls.demonum == -1)
        return;     // don't play demos
 
    if (!cls.demos[cls.demonum][0] || cls.demonum == MAX_DEMOS)
    {
        cls.demonum = 0;
        if (!cls.demos[cls.demonum][0])
        {
            Con_Print("No demos listed with startdemos\n");
            cls.demonum = -1;
            return;
        }
    }
 
    dpsnprintf (str, sizeof(str), "playdemo %s\n", cls.demos[cls.demonum]);
    Cbuf_InsertText(cmd_local, str);
    cls.demonum++;
}

References Cbuf_InsertText(), cls, cmd_local, Con_Print(), dpsnprintf(), MAX_DEMOS, and MAX_INPUTLINE.

Referenced by CL_Demos_f(), CL_ParseServerMessage(), and CL_Startdemos_f().

CL_PasteDemo()

void CL_PasteDemo	(	unsigned char **	buf,
		fs_offset_t *	filesize )

Definition at line 160 of file cl_demo.c.

{
    fs_offset_t startoffset = 0;
 
    if(!*buf)
        return;
 
    // skip cdtrack
    while(startoffset < *filesize && ((char *)(*buf))[startoffset] != '\n')
        ++startoffset;
    if(startoffset < *filesize)
        ++startoffset;
 
    FS_Write(cls.demofile, *buf + startoffset, *filesize - startoffset);
 
    Mem_Free(*buf);
    *buf = NULL;
    *filesize = 0;
}

References buf, cls, FS_Write(), Mem_Free, and NULL.

Referenced by CL_VM_Init().

CL_PauseDemo_f()

void CL_PauseDemo_f ( cmd_state_t * cmd )

static

Definition at line 728 of file cl_demo.c.

{
    cls.demopaused = !cls.demopaused;
    if (cls.demopaused)
        Con_Print("Demo paused\n");
    else
        Con_Print("Demo unpaused\n");
}

References cls, cmd(), and Con_Print().

Referenced by CL_Demo_Init().

CL_PlayDemo()

void CL_PlayDemo

(

const char *

demo

)

Definition at line 413 of file cl_demo.c.

{
    char name[MAX_QPATH];
    int c;
    qbool neg = false;
    qfile_t *f;
 
    // open the demo file
    dp_strlcpy (name, demo, sizeof (name));
    FS_DefaultExtension (name, ".dem", sizeof (name));
    f = FS_OpenVirtualFile(name, false);
    if (!f)
    {
        Con_Printf(CON_ERROR "ERROR: couldn't open %s.\n", name);
        cls.demonum = -1;        // stop demo loop
        return;
    }
 
    cls.demostarting = true;
 
    // disconnect from server
    CL_Disconnect();
 
    // update networking ports (this is mainly just needed at startup)
    NetConn_UpdateSockets();
 
    cls.protocol = PROTOCOL_QUAKE;
 
    Con_Printf("Playing demo %s.\n", name);
    cls.demofile = f;
    dp_strlcpy(cls.demoname, name, sizeof(cls.demoname));
 
    cls.demoplayback = true;
    cls.state = ca_connected;
    cls.forcetrack = 0;
 
    while ((c = FS_Getc (cls.demofile)) != '\n')
        if (c == '-')
            neg = true;
        else
            cls.forcetrack = cls.forcetrack * 10 + (c - '0');
 
    if (neg)
        cls.forcetrack = -cls.forcetrack;
 
    cls.demostarting = false;
}

References ca_connected, CL_Disconnect(), cls, CON_ERROR, Con_Printf(), dp_strlcpy, f, FS_DefaultExtension(), FS_Getc(), FS_OpenVirtualFile(), MAX_QPATH, name, NetConn_UpdateSockets(), and PROTOCOL_QUAKE.

Referenced by CL_PlayDemo_f(), and CL_TimeDemo_f().

CL_PlayDemo_f()

void CL_PlayDemo_f

(

cmd_state_t *

cmd

)

Definition at line 468 of file cl_demo.c.

{
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Print("playdemo <demoname> : plays a demo\n");
        return;
    }
 
    CL_PlayDemo(Cmd_Argv(cmd, 1));
}

References CL_PlayDemo(), cmd(), Cmd_Argc(), Cmd_Argv(), and Con_Print().

Referenced by CL_Demo_Init().

CL_ReadDemoMessage()

void CL_ReadDemoMessage

(

void

)

Definition at line 187 of file cl_demo.c.

{
    int i;
    float f;
 
    if (!cls.demoplayback)
        return;
 
    // LadyHavoc: pausedemo
    if (cls.demopaused)
        return;
 
    for (;;)
    {
        // decide if it is time to grab the next message
        // always grab until fully connected
        if (cls.signon == SIGNONS)
        {
            if (cls.timedemo)
            {
                cls.td_frames++;
                cls.td_onesecondframes++;
                // if this is the first official frame we can now grab the real
                // td_starttime so the bogus time on the first frame doesn't
                // count against the final report
                if (cls.td_frames == 0)
                {
                    cls.td_starttime = host.realtime;
                    cls.td_onesecondnexttime = cl.time + 1;
                    cls.td_onesecondrealtime = host.realtime;
                    cls.td_onesecondframes = 0;
                    cls.td_onesecondminfps = 0;
                    cls.td_onesecondmaxfps = 0;
                    cls.td_onesecondavgfps = 0;
                    cls.td_onesecondavgcount = 0;
                }
                if (cl.time >= cls.td_onesecondnexttime)
                {
                    double fps = cls.td_onesecondframes / (host.realtime - cls.td_onesecondrealtime);
                    if (cls.td_onesecondavgcount == 0)
                    {
                        cls.td_onesecondminfps = fps;
                        cls.td_onesecondmaxfps = fps;
                    }
                    cls.td_onesecondrealtime = host.realtime;
                    cls.td_onesecondminfps = min(cls.td_onesecondminfps, fps);
                    cls.td_onesecondmaxfps = max(cls.td_onesecondmaxfps, fps);
                    cls.td_onesecondavgfps += fps;
                    cls.td_onesecondavgcount++;
                    cls.td_onesecondframes = 0;
                    cls.td_onesecondnexttime++;
                }
            }
            else if (cl.time < cl.mtime[0])
            {
                // don't need another message yet
                return;
            }
        }
 
        /* At signon 1 the cl_begindownloads command starts the world and, if applicable,
         * boots up CSQC which may be required to parse the next message.
         * That will be delayed if curl must first (down)load the map.
         */
        if (cls.signon == 1 && cl.loadcsqc) // waiting for CL_VM_Init() to be called
            return;
 
        // get the next message
        FS_Read(cls.demofile, &cl_message.cursize, 4);
        cl_message.cursize = LittleLong(cl_message.cursize);
        if(cl_message.cursize & DEMOMSG_CLIENT_TO_SERVER) // This is a client->server message! Ignore for now!
        {
            // skip over demo packet
            FS_Seek(cls.demofile, 12 + (cl_message.cursize & (~DEMOMSG_CLIENT_TO_SERVER)), SEEK_CUR);
            continue;
        }
        if (cl_message.cursize > cl_message.maxsize)
        {
            CL_DisconnectEx(false, "Demo message (%i) > cl_message.maxsize (%i)", cl_message.cursize, cl_message.maxsize);
            cl_message.cursize = 0;
            return;
        }
        VectorCopy(cl.mviewangles[0], cl.mviewangles[1]);
        for (i = 0;i < 3;i++)
        {
            FS_Read(cls.demofile, &f, 4);
            cl.mviewangles[0][i] = LittleFloat(f);
        }
 
        if (FS_Read(cls.demofile, cl_message.data, cl_message.cursize) == cl_message.cursize)
        {
            MSG_BeginReading(&cl_message);
            CL_ParseServerMessage();
 
            if (cls.signon != SIGNONS)
                Cbuf_Execute((cmd_local)->cbuf); // immediately execute svc_stufftext if in the demo before connect!
 
            // In case the demo contains a "svc_disconnect" message
            if (!cls.demoplayback)
                return;
 
            if (cls.timedemo)
                return;
        }
        else
        {
            CL_Disconnect();
            return;
        }
    }
}

References Cbuf_Execute(), cl, CL_Disconnect(), CL_DisconnectEx(), cl_message, CL_ParseServerMessage(), cls, cmd_local, DEMOMSG_CLIENT_TO_SERVER, f, FS_Read(), FS_Seek(), host, LittleFloat, LittleLong, max, min, MSG_BeginReading(), SIGNONS, and VectorCopy.

Referenced by CL_Frame().

CL_Record_f()

void CL_Record_f

(

cmd_state_t *

cmd

)

Definition at line 346 of file cl_demo.c.

{
    int c, track;
    char name[MAX_OSPATH];
    char vabuf[1024];
    int vabuf_len;
 
    c = Cmd_Argc(cmd);
    if (c != 2 && c != 3 && c != 4)
    {
        Con_Print("record <demoname> [<map> [cd track]]\n");
        return;
    }
 
    if (strstr(Cmd_Argv(cmd, 1), ".."))
    {
        Con_Print("Relative pathnames are not allowed.\n");
        return;
    }
 
    if (c == 2 && cls.state == ca_connected)
    {
        Con_Print("Can not record - already connected to server\nClient demo recording must be started before connecting\n");
        return;
    }
 
    if (cls.state == ca_connected)
        CL_Disconnect();
 
    // write the forced cd track number, or -1
    if (c == 4)
    {
        track = atoi(Cmd_Argv(cmd, 3));
        Con_Printf("Forcing CD track to %i\n", cls.forcetrack);
    }
    else
        track = -1;
 
    // get the demo name
    dp_strlcpy (name, Cmd_Argv(cmd, 1), sizeof (name));
    FS_DefaultExtension (name, ".dem", sizeof (name));
 
    // start the map up
    if (c > 2)
    {
        vabuf_len = dpsnprintf(vabuf, sizeof(vabuf), "map %s", Cmd_Argv(cmd, 2));
        Cmd_ExecuteString(cmd, vabuf, vabuf_len, src_local, false);
    }
 
    // open the demo file
    Con_Printf("recording to %s.\n", name);
    cls.demofile = FS_OpenRealFile(name, "wb", false);
    if (!cls.demofile)
    {
        Con_Print(CON_ERROR "ERROR: couldn't open.\n");
        return;
    }
    dp_strlcpy(cls.demoname, name, sizeof(cls.demoname));
 
    cls.forcetrack = track;
    FS_Printf(cls.demofile, "%i\n", cls.forcetrack);
 
    cls.demorecording = true;
    cls.demo_lastcsprogssize = -1;
    cls.demo_lastcsprogscrc = -1;
}

References ca_connected, CL_Disconnect(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Cmd_ExecuteString(), CON_ERROR, Con_Print(), Con_Printf(), dp_strlcpy, dpsnprintf(), FS_DefaultExtension(), FS_OpenRealFile(), FS_Printf(), MAX_OSPATH, name, and src_local.

Referenced by CL_Demo_Init().

CL_Startdemos_f()

void CL_Startdemos_f ( cmd_state_t * cmd )

static

Definition at line 654 of file cl_demo.c.

{
    int     i, c;
 
    if (cls.state == ca_dedicated || Sys_CheckParm("-listen") || Sys_CheckParm("-benchmark") || Sys_CheckParm("-demo") || Sys_CheckParm("-capturedemo"))
        return;
 
    c = Cmd_Argc(cmd) - 1;
    if (c > MAX_DEMOS)
    {
        Con_Printf("Max %i demos in demoloop\n", MAX_DEMOS);
        c = MAX_DEMOS;
    }
    Con_DPrintf("%i demo(s) in loop\n", c);
 
    for (i=1 ; i<c+1 ; i++)
        dp_strlcpy (cls.demos[i-1], Cmd_Argv(cmd, i), sizeof (cls.demos[i-1]));
 
    // LadyHavoc: clear the remaining slots
    for (;i <= MAX_DEMOS;i++)
        cls.demos[i-1][0] = 0;
 
    if (!sv.active && cls.demonum != -1 && !cls.demoplayback)
    {
        if (!cl_startdemos.integer)
        {
            cls.demonum = -1;
#ifdef CONFIG_MENU
            // make the menu appear after a gamedir change
            if(MR_ToggleMenu)
                MR_ToggleMenu(1);
#endif
            return;
        }
        cls.demonum = 0;
        CL_NextDemo ();
    }
    else
        cls.demonum = -1;
}

References ca_dedicated, CL_NextDemo(), cl_startdemos, cls, cmd(), Cmd_Argc(), Cmd_Argv(), Con_DPrintf(), Con_Printf(), dp_strlcpy, MAX_DEMOS, MR_ToggleMenu, sv, and Sys_CheckParm().

Referenced by CL_Demo_Init().

CL_Stop_f()

void CL_Stop_f

(

cmd_state_t *

cmd

)

Definition at line 307 of file cl_demo.c.

{
    sizebuf_t buf;
    unsigned char bufdata[64];
 
    if (!cls.demorecording)
    {
        Con_Print("Not recording a demo.\n");
        return;
    }
 
// write a disconnect message to the demo file
    // LadyHavoc: don't replace the cl_message when doing this
    buf.data = bufdata;
    buf.maxsize = sizeof(bufdata);
    SZ_Clear(&buf);
    MSG_WriteByte(&buf, svc_disconnect);
    CL_WriteDemoMessage(&buf);
 
// finish up
    if(cl_autodemo.integer && (cl_autodemo_delete.integer & 1))
    {
        FS_RemoveOnClose(cls.demofile);
        Con_Print("Completed and deleted demo\n");
    }
    else
        Con_Print("Completed demo\n");
    FS_Close (cls.demofile);
    cls.demofile = NULL;
    cls.demorecording = false;
}

References buf, cl_autodemo, cl_autodemo_delete, CL_WriteDemoMessage(), cls, cmd(), Con_Print(), FS_Close(), FS_RemoveOnClose(), MSG_WriteByte(), NULL, svc_disconnect, and SZ_Clear().

Referenced by CL_Demo_Init(), CL_DisconnectEx(), CL_ParseServerInfo(), and Sys_Error().

CL_Stopdemo_f()

void CL_Stopdemo_f ( cmd_state_t * cmd )

static

Definition at line 720 of file cl_demo.c.

{
    if (!cls.demoplayback)
        return;
    CL_Disconnect();
}

References CL_Disconnect(), cls, and cmd().

Referenced by CL_Demo_Init().

CL_StopPlayback()

void CL_StopPlayback

(

void

)

Definition at line 81 of file cl_demo.c.

{
#ifdef CONFIG_VIDEO_CAPTURE
    if (cl_capturevideo_demo_stop.integer)
        Cvar_SetQuick(&cl_capturevideo, "0");
#endif
 
    if (!cls.demoplayback)
        return;
 
    FS_Close (cls.demofile);
    cls.demoplayback = false;
    cls.demofile = NULL;
 
    if (cls.timedemo)
        CL_FinishTimeDemo ();
 
    if (!cls.demostarting) // only quit if not starting another demo
        if (Sys_CheckParm("-demo") || Sys_CheckParm("-capturedemo"))
            host.state = host_shutdown;
}

References CL_FinishTimeDemo(), cls, Cvar_SetQuick(), FS_Close(), host, host_shutdown, cvar_t::integer, NULL, and Sys_CheckParm().

Referenced by CL_DisconnectEx().

CL_TimeDemo_f()

void CL_TimeDemo_f

(

cmd_state_t *

cmd

)

Definition at line 612 of file cl_demo.c.

{
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Print("timedemo <demoname> : gets demo speeds\n");
        return;
    }
 
    srand(0); // predictable random sequence for benchmarking
 
    CL_PlayDemo(Cmd_Argv(cmd, 1));
 
// cls.td_starttime will be grabbed at the second frame of the demo, so
// all the loading time doesn't get counted
 
    // instantly hide console and deactivate it
    key_dest = key_game;
    key_consoleactive = 0;
    scr_con_current = 0;
 
    cls.timedemo = host.restless = true;
    cls.td_frames = -2;      // skip the first frame
    cls.demonum = -1;        // stop demo loop
 
    // Might need to disable vsync
    Cvar_Callback(&vid_vsync);
}

References CL_PlayDemo(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Cvar_Callback(), host, key_consoleactive, key_dest, key_game, scr_con_current, and vid_vsync.

Referenced by CL_Demo_Init().

CL_WriteDemoMessage()

void CL_WriteDemoMessage

(

sizebuf_t *

message

)

Definition at line 110 of file cl_demo.c.

{
    int     len;
    int     i;
    float   f;
 
    if (cls.demopaused) // LadyHavoc: pausedemo
        return;
 
    len = LittleLong (message->cursize);
    FS_Write (cls.demofile, &len, 4);
    for (i=0 ; i<3 ; i++)
    {
        f = LittleFloat (cl.viewangles[i]);
        FS_Write (cls.demofile, &f, 4);
    }
    FS_Write (cls.demofile, message->data, message->cursize);
}

References cl, cls, f, FS_Write(), LittleFloat, LittleLong, and message.

Referenced by CL_ParseServerMessage(), CL_Stop_f(), and CL_VM_Init().

doublecmp_withoffset()

int doublecmp_withoffset ( const void * a_, const void * b_ )

static

Definition at line 487 of file cl_demo.c.

{
    const double *a = (const double *) ((const char *) a_ + doublecmp_offset);
    const double *b = (const double *) ((const char *) b_ + doublecmp_offset);
    if(*a > *b)
        return +1;
    if(*a < *b)
        return -1;
    return 0;
}

References a, b, and doublecmp_offset.

Variable Documentation

doublecmp_offset

size_t doublecmp_offset

static

Definition at line 486 of file cl_demo.c.

Referenced by doublecmp_withoffset().