diff options
Diffstat (limited to 'src/mvd_client.c')
| -rw-r--r-- | src/mvd_client.c | 1717 |
1 files changed, 896 insertions, 821 deletions
diff --git a/src/mvd_client.c b/src/mvd_client.c index 5aac403..22c9da7 100644 --- a/src/mvd_client.c +++ b/src/mvd_client.c @@ -8,7 +8,7 @@ of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -27,13 +27,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "net_stream.h" #include <setjmp.h> -#define FOR_EACH_GTV( gtv ) \ - LIST_FOR_EACH( gtv_t, gtv, &mvd_gtv_list, entry ) +#define FOR_EACH_GTV(gtv) \ + LIST_FOR_EACH(gtv_t, gtv, &mvd_gtv_list, entry) -#define GTV_DEFAULT_BACKOFF (5*1000) // 5 seconds -#define GTV_MAXIMUM_BACKOFF (5*3600*1000) // 5 hours +#define GTV_DEFAULT_BACKOFF (5 * 1000) // 5 seconds +#define GTV_MAXIMUM_BACKOFF (5 * 3600 * 1000) // 5 hours -#define GTV_PING_INTERVAL (60*1000) // 1 minute +#define GTV_PING_INTERVAL (60 * 1000) // 1 minute typedef enum { GTV_DISCONNECTED, // disconnected @@ -55,9 +55,9 @@ typedef struct gtv_s { char name[MAX_MVD_NAME]; gtv_state_t state; mvd_t *mvd; - void (*drop)( struct gtv_s * ); - void (*destroy)( struct gtv_s * ); - void (*run)( struct gtv_s * ); + void (*drop)(struct gtv_s *); + void (*destroy)(struct gtv_s *); + void (*run)(struct gtv_s *); // connection variables char *username, *password; @@ -99,8 +99,8 @@ static const char *const mvd_states[MVD_NUM_STATES] = { "DEAD", "WAIT", "READ" }; -LIST_DECL( mvd_gtv_list ); -LIST_DECL( mvd_channel_list ); +LIST_DECL(mvd_gtv_list); +LIST_DECL(mvd_channel_list); mvd_t mvd_waitingRoom; qboolean mvd_dirty; @@ -125,98 +125,103 @@ static cvar_t *mvd_snaps; // ==================================================================== -void MVD_StopRecord( mvd_t *mvd ) { +void MVD_StopRecord(mvd_t *mvd) +{ uint16_t msglen; msglen = 0; - FS_Write( &msglen, 2, mvd->demorecording ); + FS_Write(&msglen, 2, mvd->demorecording); - FS_FCloseFile( mvd->demorecording ); + FS_FCloseFile(mvd->demorecording); mvd->demorecording = 0; - Z_Free( mvd->demoname ); + Z_Free(mvd->demoname); mvd->demoname = NULL; } -static void MVD_Free( mvd_t *mvd ) { +static void MVD_Free(mvd_t *mvd) +{ mvd_snap_t *snap, *next; int i; - LIST_FOR_EACH_SAFE( mvd_snap_t, snap, next, &mvd->snapshots, entry ) { - Z_Free( snap ); + LIST_FOR_EACH_SAFE(mvd_snap_t, snap, next, &mvd->snapshots, entry) { + Z_Free(snap); } // stop demo recording - if( mvd->demorecording ) { - MVD_StopRecord( mvd ); + if (mvd->demorecording) { + MVD_StopRecord(mvd); } - for( i = 0; i < mvd->maxclients; i++ ) { - MVD_FreePlayer( &mvd->players[i] ); + for (i = 0; i < mvd->maxclients; i++) { + MVD_FreePlayer(&mvd->players[i]); } - Z_Free( mvd->players ); + Z_Free(mvd->players); - CM_FreeMap( &mvd->cm ); + CM_FreeMap(&mvd->cm); - Z_Free( mvd->delay.data ); + Z_Free(mvd->delay.data); - List_Remove( &mvd->entry ); - Z_Free( mvd ); + List_Remove(&mvd->entry); + Z_Free(mvd); } -static void MVD_Destroy( mvd_t *mvd ) { +static void MVD_Destroy(mvd_t *mvd) +{ mvd_client_t *client, *next; // update channel menus - if( !LIST_EMPTY( &mvd->entry ) ) { + if (!LIST_EMPTY(&mvd->entry)) { mvd_dirty = qtrue; } // cause UDP clients to reconnect - LIST_FOR_EACH_SAFE( mvd_client_t, client, next, &mvd->clients, entry ) { - MVD_SwitchChannel( client, &mvd_waitingRoom ); + LIST_FOR_EACH_SAFE(mvd_client_t, client, next, &mvd->clients, entry) { + MVD_SwitchChannel(client, &mvd_waitingRoom); } // destroy any existing GTV connection - if( mvd->gtv ) { + if (mvd->gtv) { mvd->gtv->mvd = NULL; // don't double destroy - mvd->gtv->destroy( mvd->gtv ); + mvd->gtv->destroy(mvd->gtv); } // free all channel data - MVD_Free( mvd ); + MVD_Free(mvd); } -void MVD_Destroyf( mvd_t *mvd, const char *fmt, ... ) { +void MVD_Destroyf(mvd_t *mvd, const char *fmt, ...) +{ va_list argptr; char text[MAXERRORMSG]; - va_start( argptr, fmt ); - Q_vsnprintf( text, sizeof( text ), fmt, argptr ); - va_end( argptr ); + va_start(argptr, fmt); + Q_vsnprintf(text, sizeof(text), fmt, argptr); + va_end(argptr); - Com_Printf( "[%s] =X= %s\n", mvd->name, text ); + Com_Printf("[%s] =X= %s\n", mvd->name, text); // notify spectators - if( Com_IsDedicated() ) { - MVD_BroadcastPrintf( mvd, PRINT_HIGH, 0, - "[MVD] %s\n", text ); + if (Com_IsDedicated()) { + MVD_BroadcastPrintf(mvd, PRINT_HIGH, 0, + "[MVD] %s\n", text); } - MVD_Destroy( mvd ); + MVD_Destroy(mvd); - longjmp( mvd_jmpbuf, -1 ); + longjmp(mvd_jmpbuf, -1); } #if USE_CLIENT -static mvd_t *find_local_channel( void ) { +static mvd_t *find_local_channel(void) +{ mvd_client_t *client; mvd_t *mvd; - FOR_EACH_MVD( mvd ) { - FOR_EACH_MVDCL( client, mvd ) { - if( NET_IsLocalAddress( &client->cl->netchan->remote_address ) ) { + FOR_EACH_MVD(mvd) { + FOR_EACH_MVDCL(client, mvd) { + if (NET_IsLocalAddress(&client->cl->netchan->remote_address)) { return mvd; } } @@ -225,48 +230,49 @@ static mvd_t *find_local_channel( void ) { } #endif -mvd_t *MVD_SetChannel( int arg ) { - char *s = Cmd_Argv( arg ); +mvd_t *MVD_SetChannel(int arg) +{ + char *s = Cmd_Argv(arg); mvd_t *mvd; int id; - if( LIST_EMPTY( &mvd_channel_list ) ) { - Com_Printf( "No active channels.\n" ); + if (LIST_EMPTY(&mvd_channel_list)) { + Com_Printf("No active channels.\n"); return NULL; } - if( !*s ) { - if( LIST_SINGLE( &mvd_channel_list ) ) { - return LIST_FIRST( mvd_t, &mvd_channel_list, entry ); + if (!*s) { + if (LIST_SINGLE(&mvd_channel_list)) { + return LIST_FIRST(mvd_t, &mvd_channel_list, entry); } - Com_Printf( "Please specify an exact channel ID.\n" ); + Com_Printf("Please specify an exact channel ID.\n"); return NULL; } #if USE_CLIENT // special value of @@ returns the channel local client is on - if( !dedicated->integer && !strcmp( s, "@@" ) ) { - if( ( mvd = find_local_channel() ) != NULL ) { + if (!dedicated->integer && !strcmp(s, "@@")) { + if ((mvd = find_local_channel()) != NULL) { return mvd; } } else #endif - if( COM_IsUint( s ) ) { - id = atoi( s ); - FOR_EACH_MVD( mvd ) { - if( mvd->id == id ) { - return mvd; + if (COM_IsUint(s)) { + id = atoi(s); + FOR_EACH_MVD(mvd) { + if (mvd->id == id) { + return mvd; + } } - } - } else { - FOR_EACH_MVD( mvd ) { - if( !strcmp( mvd->name, s ) ) { - return mvd; + } else { + FOR_EACH_MVD(mvd) { + if (!strcmp(mvd->name, s)) { + return mvd; + } } } - } - Com_Printf( "No such channel ID: %s\n", s ); + Com_Printf("No such channel ID: %s\n", s); return NULL; } @@ -278,91 +284,95 @@ COMMON GTV STUFF ==================================================================== */ -static void q_noreturn q_printf( 2, 3 ) -gtv_dropf( gtv_t *gtv, const char *fmt, ... ) { +static void q_noreturn q_printf(2, 3) +gtv_dropf(gtv_t *gtv, const char *fmt, ...) +{ va_list argptr; char text[MAXERRORMSG]; - va_start( argptr, fmt ); - Q_vsnprintf( text, sizeof( text ), fmt, argptr ); - va_end( argptr ); + va_start(argptr, fmt); + Q_vsnprintf(text, sizeof(text), fmt, argptr); + va_end(argptr); - Com_Printf( "[%s] =!= %s\n", gtv->name, text ); + Com_Printf("[%s] =!= %s\n", gtv->name, text); - gtv->drop( gtv ); + gtv->drop(gtv); - longjmp( mvd_jmpbuf, -1 ); + longjmp(mvd_jmpbuf, -1); } -static void q_noreturn q_printf( 2, 3 ) -gtv_destroyf( gtv_t *gtv, const char *fmt, ... ) { +static void q_noreturn q_printf(2, 3) +gtv_destroyf(gtv_t *gtv, const char *fmt, ...) +{ va_list argptr; char text[MAXERRORMSG]; - va_start( argptr, fmt ); - Q_vsnprintf( text, sizeof( text ), fmt, argptr ); - va_end( argptr ); + va_start(argptr, fmt); + Q_vsnprintf(text, sizeof(text), fmt, argptr); + va_end(argptr); - Com_Printf( "[%s] =X= %s\n", gtv->name, text ); + Com_Printf("[%s] =X= %s\n", gtv->name, text); - gtv->destroy( gtv ); + gtv->destroy(gtv); - longjmp( mvd_jmpbuf, -1 ); + longjmp(mvd_jmpbuf, -1); } -static mvd_t *create_channel( gtv_t *gtv ) { +static mvd_t *create_channel(gtv_t *gtv) +{ mvd_t *mvd; - mvd = MVD_Mallocz( sizeof( *mvd ) ); + mvd = MVD_Mallocz(sizeof(*mvd)); mvd->gtv = gtv; mvd->id = gtv->id; - Q_strlcpy( mvd->name, gtv->name, sizeof( mvd->name ) ); + Q_strlcpy(mvd->name, gtv->name, sizeof(mvd->name)); mvd->pool.edicts = mvd->edicts; - mvd->pool.edict_size = sizeof( edict_t ); + mvd->pool.edict_size = sizeof(edict_t); mvd->pool.max_edicts = MAX_EDICTS; mvd->pm_type = PM_SPECTATOR; mvd->min_packets = mvd_wait_delay->value * 10; - List_Init( &mvd->snapshots ); - List_Init( &mvd->clients ); - List_Init( &mvd->entry ); + List_Init(&mvd->snapshots); + List_Init(&mvd->clients); + List_Init(&mvd->entry); return mvd; } -static gtv_t *gtv_set_conn( int arg ) { - char *s = Cmd_Argv( arg ); +static gtv_t *gtv_set_conn(int arg) +{ + char *s = Cmd_Argv(arg); gtv_t *gtv; int id; - if( LIST_EMPTY( &mvd_gtv_list ) ) { - Com_Printf( "No GTV connections.\n" ); + if (LIST_EMPTY(&mvd_gtv_list)) { + Com_Printf("No GTV connections.\n"); return NULL; } - if( !*s ) { - if( LIST_SINGLE( &mvd_gtv_list ) ) { - return LIST_FIRST( gtv_t, &mvd_gtv_list, entry ); + if (!*s) { + if (LIST_SINGLE(&mvd_gtv_list)) { + return LIST_FIRST(gtv_t, &mvd_gtv_list, entry); } - Com_Printf( "Please specify an exact connection ID.\n" ); + Com_Printf("Please specify an exact connection ID.\n"); return NULL; } - if( COM_IsUint( s ) ) { - id = atoi( s ); - FOR_EACH_GTV( gtv ) { - if( gtv->id == id ) { + if (COM_IsUint(s)) { + id = atoi(s); + FOR_EACH_GTV(gtv) { + if (gtv->id == id) { return gtv; } } } else { - FOR_EACH_GTV( gtv ) { - if( !strcmp( gtv->name, s ) ) { + FOR_EACH_GTV(gtv) { + if (!strcmp(gtv->name, s)) { return gtv; } } } - Com_Printf( "No such connection ID: %s\n", s ); + Com_Printf("No such connection ID: %s\n", s); return NULL; } @@ -373,36 +383,37 @@ MVD_Frame Called from main server loop. ============== */ -int MVD_Frame( void ) { +int MVD_Frame(void) +{ static unsigned prevtime; gtv_t *gtv, *next; int connections = 0; - if( sv.state == ss_broadcast ) { + if (sv.state == ss_broadcast) { unsigned delta = mvd_suspend_time->value * 60 * 1000; - if( !delta || !LIST_EMPTY( &sv_clientlist ) ) { + if (!delta || !LIST_EMPTY(&sv_clientlist)) { prevtime = svs.realtime; - if( !mvd_active ) { - Com_DPrintf( "Resuming MVD streams.\n" ); + if (!mvd_active) { + Com_DPrintf("Resuming MVD streams.\n"); mvd_active = qtrue; } - } else if( mvd_active ) { - if( svs.realtime - prevtime > delta ) { - Com_DPrintf( "Suspending MVD streams.\n" ); + } else if (mvd_active) { + if (svs.realtime - prevtime > delta) { + Com_DPrintf("Suspending MVD streams.\n"); mvd_active = qfalse; } } } // run all GTV connections (but not demos) - LIST_FOR_EACH_SAFE( gtv_t, gtv, next, &mvd_gtv_list, entry ) { - if( setjmp( mvd_jmpbuf ) ) { - SZ_Clear( &msg_write ); + LIST_FOR_EACH_SAFE(gtv_t, gtv, next, &mvd_gtv_list, entry) { + if (setjmp(mvd_jmpbuf)) { + SZ_Clear(&msg_write); continue; } - gtv->run( gtv ); + gtv->run(gtv); connections++; } @@ -411,25 +422,26 @@ int MVD_Frame( void ) { } #if USE_CLIENT -int MVD_GetDemoPercent( qboolean *paused, int *framenum ) { +int MVD_GetDemoPercent(qboolean *paused, int *framenum) +{ mvd_t *mvd; gtv_t *gtv; - if( ( mvd = find_local_channel() ) == NULL ) + if ((mvd = find_local_channel()) == NULL) return -1; - if( ( gtv = mvd->gtv ) == NULL ) + if ((gtv = mvd->gtv) == NULL) return -1; - if( !gtv->demoplayback ) + if (!gtv->demoplayback) return -1; - if( paused ) + if (paused) *paused = mvd->state == MVD_WAITING ? qtrue : qfalse; - if( framenum ) + if (framenum) *framenum = mvd->framenum; - if( !gtv->demosize ) + if (!gtv->demosize) return -1; return gtv->demopos * 100 / gtv->demosize; @@ -444,101 +456,106 @@ DEMO PLAYER ==================================================================== */ -static void demo_play_next( gtv_t *gtv, string_entry_t *entry ); +static void demo_play_next(gtv_t *gtv, string_entry_t *entry); -static void emit_base_frame( mvd_t *mvd ); +static void emit_base_frame(mvd_t *mvd); -static ssize_t demo_load_message( qhandle_t f ) { +static ssize_t demo_load_message(qhandle_t f) +{ uint16_t us; ssize_t msglen, read; - read = FS_Read( &us, 2, f ); - if( read != 2 ) { + read = FS_Read(&us, 2, f); + if (read != 2) { return read < 0 ? read : Q_ERR_UNEXPECTED_EOF; } - if( !us ) { + if (!us) { return 0; } - msglen = LittleShort( us ); - if( msglen > MAX_MSGLEN ) { + msglen = LittleShort(us); + if (msglen > MAX_MSGLEN) { return Q_ERR_INVALID_FORMAT; } - read = FS_Read( msg_read_buffer, msglen, f ); - if( read != msglen ) { + read = FS_Read(msg_read_buffer, msglen, f); + if (read != msglen) { return read < 0 ? read : Q_ERR_UNEXPECTED_EOF; } return read; } -static ssize_t demo_skip_map( qhandle_t f ) { +static ssize_t demo_skip_map(qhandle_t f) +{ ssize_t msglen; - while( 1 ) { - if( ( msglen = demo_load_message( f ) ) <= 0 ) { + while (1) { + if ((msglen = demo_load_message(f)) <= 0) { return msglen; } - if( msg_read_buffer[0] == mvd_serverdata ) { + if (msg_read_buffer[0] == mvd_serverdata) { break; - } + } } - SZ_Init( &msg_read, msg_read_buffer, sizeof( msg_read_buffer ) ); + SZ_Init(&msg_read, msg_read_buffer, sizeof(msg_read_buffer)); msg_read.cursize = msglen; return msglen; } -static ssize_t demo_read_message( qhandle_t f ) { +static ssize_t demo_read_message(qhandle_t f) +{ ssize_t msglen; - if( ( msglen = demo_load_message( f ) ) <= 0 ) { + if ((msglen = demo_load_message(f)) <= 0) { return msglen; } - SZ_Init( &msg_read, msg_read_buffer, sizeof( msg_read_buffer ) ); + SZ_Init(&msg_read, msg_read_buffer, sizeof(msg_read_buffer)); msg_read.cursize = msglen; return msglen; } -static ssize_t demo_read_first( qhandle_t f ) { +static ssize_t demo_read_first(qhandle_t f) +{ uint32_t magic; ssize_t read; qerror_t ret; // read magic - read = FS_Read( &magic, 4, f ); - if( read != 4 ) { + read = FS_Read(&magic, 4, f); + if (read != 4) { return read < 0 ? read : Q_ERR_UNEXPECTED_EOF; } // check for gzip header - if( CHECK_GZIP_HEADER( magic ) ) { - ret = FS_FilterFile( f ); - if( ret ) { + if (CHECK_GZIP_HEADER(magic)) { + ret = FS_FilterFile(f); + if (ret) { return ret; } - read = FS_Read( &magic, 4, f ); - if( read != 4 ) { + read = FS_Read(&magic, 4, f); + if (read != 4) { return read < 0 ? read : Q_ERR_UNEXPECTED_EOF; } } - if( magic != MVD_MAGIC ) { + if (magic != MVD_MAGIC) { return Q_ERR_UNKNOWN_FORMAT; } // read the first message - read = demo_read_message( f ); + read = demo_read_message(f); return read ? read : Q_ERR_UNEXPECTED_EOF; } // periodically builds a fake demo packet used to reconstruct delta compression // state, configstrings and layouts at the given server frame. -static void demo_emit_snapshot( mvd_t *mvd ) { +static void demo_emit_snapshot(mvd_t *mvd) +{ mvd_snap_t *snap; gtv_t *gtv; off_t pos; @@ -546,71 +563,72 @@ static void demo_emit_snapshot( mvd_t *mvd ) { size_t len; int i; - if( mvd_snaps->integer <= 0 ) + if (mvd_snaps->integer <= 0) return; - if( mvd->framenum < mvd->last_snapshot + mvd_snaps->integer * 10 ) + if (mvd->framenum < mvd->last_snapshot + mvd_snaps->integer * 10) return; gtv = mvd->gtv; - if( !gtv ) + if (!gtv) return; - if( !gtv->demosize ) + if (!gtv->demosize) return; - pos = FS_Tell( gtv->demoplayback ); - if( pos < gtv->demopos ) + pos = FS_Tell(gtv->demoplayback); + if (pos < gtv->demopos) return; // write baseline frame - MSG_WriteByte( mvd_frame ); - emit_base_frame( mvd ); + MSG_WriteByte(mvd_frame); + emit_base_frame(mvd); // write configstrings - for( i = 0; i < MAX_CONFIGSTRINGS; i++ ) { + for (i = 0; i < MAX_CONFIGSTRINGS; i++) { from = mvd->baseconfigstrings[i]; to = mvd->configstrings[i]; - if( !strcmp( from, to ) ) + if (!strcmp(from, to)) continue; - len = strlen( to ); - if( len > MAX_QPATH ) + len = strlen(to); + if (len > MAX_QPATH) len = MAX_QPATH; - MSG_WriteByte( mvd_configstring ); - MSG_WriteShort( i ); - MSG_WriteData( to, len ); - MSG_WriteByte( 0 ); + MSG_WriteByte(mvd_configstring); + MSG_WriteShort(i); + MSG_WriteData(to, len); + MSG_WriteByte(0); } // TODO: write private layouts/configstrings - snap = MVD_Malloc( sizeof( *snap ) + msg_write.cursize - 1 ); + snap = MVD_Malloc(sizeof(*snap) + msg_write.cursize - 1); snap->framenum = mvd->framenum; snap->filepos = pos; snap->msglen = msg_write.cursize; - memcpy( snap->data, msg_write.data, msg_write.cursize ); - List_Append( &mvd->snapshots, &snap->entry ); + memcpy(snap->data, msg_write.data, msg_write.cursize); + List_Append(&mvd->snapshots, &snap->entry); - Com_DPrintf( "[%d] snaplen %"PRIz"\n", mvd->framenum, msg_write.cursize ); + Com_DPrintf("[%d] snaplen %"PRIz"\n", mvd->framenum, msg_write.cursize); - SZ_Clear( &msg_write ); + SZ_Clear(&msg_write); mvd->last_snapshot = mvd->framenum; } -static mvd_snap_t *demo_find_snapshot( mvd_t *mvd, int framenum ) { +static mvd_snap_t *demo_find_snapshot(mvd_t *mvd, int framenum) +{ mvd_snap_t *snap, *prev; - if( LIST_EMPTY( &mvd->snapshots ) ) + if (LIST_EMPTY(&mvd->snapshots)) return NULL; - prev = LIST_FIRST( mvd_snap_t, &mvd->snapshots, entry ); + prev = LIST_FIRST(mvd_snap_t, &mvd->snapshots, entry); - LIST_FOR_EACH( mvd_snap_t, snap, &mvd->snapshots, entry ) { - if( snap->framenum > framenum ) + LIST_FOR_EACH(mvd_snap_t, snap, &mvd->snapshots, entry) { + if (snap->framenum > framenum) break; prev = snap; } @@ -618,34 +636,37 @@ static mvd_snap_t *demo_find_snapshot( mvd_t *mvd, int framenum ) { return prev; } -static void demo_update( gtv_t *gtv ) { - if( gtv->demosize ) { - gtv->demopos = FS_Tell( gtv->demoplayback ); +static void demo_update(gtv_t *gtv) +{ + if (gtv->demosize) { + gtv->demopos = FS_Tell(gtv->demoplayback); } } -static void demo_finish( gtv_t *gtv, ssize_t ret ) { - if( ret < 0 ) { - gtv_destroyf( gtv, "Couldn't read %s: %s", gtv->demoentry->string, Q_ErrorString( ret ) ); +static void demo_finish(gtv_t *gtv, ssize_t ret) +{ + if (ret < 0) { + gtv_destroyf(gtv, "Couldn't read %s: %s", gtv->demoentry->string, Q_ErrorString(ret)); } - demo_play_next( gtv, gtv->demoentry->next ); + demo_play_next(gtv, gtv->demoentry->next); } -static qboolean demo_read_frame( mvd_t *mvd ) { +static qboolean demo_read_frame(mvd_t *mvd) +{ gtv_t *gtv = mvd->gtv; int count; ssize_t ret; - if( mvd->state == MVD_WAITING ) { + if (mvd->state == MVD_WAITING) { return qfalse; // paused by user } - if( !gtv ) { - MVD_Destroyf( mvd, "End of MVD stream reached" ); + if (!gtv) { + MVD_Destroyf(mvd, "End of MVD stream reached"); } - if( gtv->demowait ) { + if (gtv->demowait) { gtv->demowait = qfalse; return qfalse; } @@ -653,76 +674,77 @@ static qboolean demo_read_frame( mvd_t *mvd ) { count = gtv->demoskip; gtv->demoskip = 0; - if( count ) { - Com_Printf( "[%s] -=- Skipping map%s...\n", gtv->name, count == 1 ? "" : "s" ); + if (count) { + Com_Printf("[%s] -=- Skipping map%s...\n", gtv->name, count == 1 ? "" : "s"); do { - ret = demo_skip_map( gtv->demoplayback ); - if( ret <= 0 ) { + ret = demo_skip_map(gtv->demoplayback); + if (ret <= 0) { goto next; } - } while( --count ); + } while (--count); } else { - ret = demo_read_message( gtv->demoplayback ); - if( ret <= 0 ) { + ret = demo_read_message(gtv->demoplayback); + if (ret <= 0) { goto next; } } - demo_update( gtv ); + demo_update(gtv); - MVD_ParseMessage( mvd ); - demo_emit_snapshot( mvd ); + MVD_ParseMessage(mvd); + demo_emit_snapshot(mvd); return qtrue; next: - demo_finish( gtv, ret ); + demo_finish(gtv, ret); return qtrue; } -static void demo_play_next( gtv_t *gtv, string_entry_t *entry ) { +static void demo_play_next(gtv_t *gtv, string_entry_t *entry) +{ ssize_t len, ret; - if( !entry ) { - if( gtv->demoloop ) { - if( --gtv->demoloop == 0 ) { - gtv_destroyf( gtv, "End of play list reached" ); + if (!entry) { + if (gtv->demoloop) { + if (--gtv->demoloop == 0) { + gtv_destroyf(gtv, "End of play list reached"); } } entry = gtv->demohead; } // close previous file - if( gtv->demoplayback ) { - FS_FCloseFile( gtv->demoplayback ); + if (gtv->demoplayback) { + FS_FCloseFile(gtv->demoplayback); gtv->demoplayback = 0; } // open new file - len = FS_FOpenFile( entry->string, >v->demoplayback, FS_MODE_READ ); - if( !gtv->demoplayback ) { - gtv_destroyf( gtv, "Couldn't open %s: %s", entry->string, Q_ErrorString( len ) ); + len = FS_FOpenFile(entry->string, >v->demoplayback, FS_MODE_READ); + if (!gtv->demoplayback) { + gtv_destroyf(gtv, "Couldn't open %s: %s", entry->string, Q_ErrorString(len)); } // read the first message - ret = demo_read_first( gtv->demoplayback ); - if( ret < 0 ) { - gtv_destroyf( gtv, "Couldn't read %s: %s", entry->string, Q_ErrorString( ret ) ); + ret = demo_read_first(gtv->demoplayback); + if (ret < 0) { + gtv_destroyf(gtv, "Couldn't read %s: %s", entry->string, Q_ErrorString(ret)); } // create MVD channel - if( !gtv->mvd ) { - gtv->mvd = create_channel( gtv ); + if (!gtv->mvd) { + gtv->mvd = create_channel(gtv); gtv->mvd->read_frame = demo_read_frame; } else { gtv->mvd->demoseeking = qfalse; } - Com_Printf( "[%s] -=- Reading from %s\n", gtv->name, entry->string ); + Com_Printf("[%s] -=- Reading from %s\n", gtv->name, entry->string); // parse gamestate - MVD_ParseMessage( gtv->mvd ); - if( !gtv->mvd->state ) { - gtv_destroyf( gtv, "First message of %s does not contain gamestate", entry->string ); + MVD_ParseMessage(gtv->mvd); + if (!gtv->mvd->state) { + gtv_destroyf(gtv, "First message of %s does not contain gamestate", entry->string); } gtv->mvd->state = MVD_READING; @@ -731,48 +753,50 @@ static void demo_play_next( gtv_t *gtv, string_entry_t *entry ) { gtv->demoentry = entry; // set channel address - Q_strlcpy( gtv->address, COM_SkipPath( entry->string ), sizeof( gtv->address ) ); + Q_strlcpy(gtv->address, COM_SkipPath(entry->string), sizeof(gtv->address)); - len = FS_Length( gtv->demoplayback ); - ret = FS_Tell( gtv->demoplayback ); - if( len > 0 && ret > 0 ) { + len = FS_Length(gtv->demoplayback); + ret = FS_Tell(gtv->demoplayback); + if (len > 0 && ret > 0) { gtv->demosize = len; gtv->demopos = ret; } else { gtv->demosize = gtv->demopos = 0; } - demo_emit_snapshot( gtv->mvd ); + demo_emit_snapshot(gtv->mvd); } -static void demo_free_playlist( gtv_t *gtv ) { +static void demo_free_playlist(gtv_t *gtv) +{ string_entry_t *entry, *next; - for( entry = gtv->demohead; entry; entry = next ) { + for (entry = gtv->demohead; entry; entry = next) { next = entry->next; - Z_Free( entry ); + Z_Free(entry); } gtv->demohead = gtv->demoentry = NULL; } -static void demo_destroy( gtv_t *gtv ) { +static void demo_destroy(gtv_t *gtv) +{ mvd_t *mvd = gtv->mvd; // destroy any associated MVD channel - if( mvd ) { + if (mvd) { mvd->gtv = NULL; - MVD_Destroy( mvd ); + MVD_Destroy(mvd); } - if( gtv->demoplayback ) { - FS_FCloseFile( gtv->demoplayback ); + if (gtv->demoplayback) { + FS_FCloseFile(gtv->demoplayback); gtv->demoplayback = 0; } - demo_free_playlist( gtv ); + demo_free_playlist(gtv); - Z_Free( gtv ); + Z_Free(gtv); } @@ -784,61 +808,65 @@ GTV CONNECTIONS ==================================================================== */ -static void write_stream( gtv_t *gtv, void *data, size_t len ) { - if( FIFO_Write( >v->stream.send, data, len ) != len ) { - gtv_destroyf( gtv, "Send buffer overflowed" ); +static void write_stream(gtv_t *gtv, void *data, size_t len) +{ + if (FIFO_Write(>v->stream.send, data, len) != len) { + gtv_destroyf(gtv, "Send buffer overflowed"); } // don't timeout gtv->last_sent = svs.realtime; } -static void write_message( gtv_t *gtv, gtv_clientop_t op ) { +static void write_message(gtv_t *gtv, gtv_clientop_t op) +{ byte header[3]; size_t len = msg_write.cursize + 1; header[0] = len & 255; - header[1] = ( len >> 8 ) & 255; + header[1] = (len >> 8) & 255; header[2] = op; - write_stream( gtv, header, sizeof( header ) ); + write_stream(gtv, header, sizeof(header)); - write_stream( gtv, msg_write.data, msg_write.cursize ); + write_stream(gtv, msg_write.data, msg_write.cursize); } -static void q_noreturn gtv_oob_kill( mvd_t *mvd ) { +static void q_noreturn gtv_oob_kill(mvd_t *mvd) +{ gtv_t *gtv = mvd->gtv; - if( gtv ) { + if (gtv) { // don't kill connection! gtv->mvd = NULL; mvd->gtv = NULL; } - MVD_Destroyf( mvd, "Ran out of buffers" ); + MVD_Destroyf(mvd, "Ran out of buffers"); } -static qboolean gtv_wait_stop( mvd_t *mvd ) { +static qboolean gtv_wait_stop(mvd_t *mvd) +{ gtv_t *gtv = mvd->gtv; int min_packets = mvd->min_packets, usage; // if not connected, flush any data left - if( !gtv || gtv->state != GTV_READING ) { - if( !mvd->num_packets ) { - gtv_oob_kill( mvd ); + if (!gtv || gtv->state != GTV_READING) { + if (!mvd->num_packets) { + gtv_oob_kill(mvd); } min_packets = 1; } // see how many frames are buffered - if( mvd->num_packets >= min_packets ) { - Com_Printf( "[%s] -=- Waiting finished, reading...\n", mvd->name ); + if (mvd->num_packets >= min_packets) { + Com_Printf("[%s] -=- Waiting finished, reading...\n", mvd->name); goto stop; } // see how much data is buffered - usage = FIFO_Percent( &mvd->delay ); - if( usage >= mvd_wait_percent->value ) { - Com_Printf( "[%s] -=- Buffering finished, reading...\n", mvd->name ); + usage = FIFO_Percent(&mvd->delay); + if (usage >= mvd_wait_percent->value) { + Com_Printf("[%s] -=- Buffering finished, reading...\n", mvd->name); goto stop; } @@ -846,9 +874,9 @@ static qboolean gtv_wait_stop( mvd_t *mvd ) { stop: // notify spectators - if( Com_IsDedicated() ) { - MVD_BroadcastPrintf( mvd, PRINT_HIGH, 0, - "[MVD] Streaming resumed.\n" ); + if (Com_IsDedicated()) { + MVD_BroadcastPrintf(mvd, PRINT_HIGH, 0, + "[MVD] Streaming resumed.\n"); } mvd->state = MVD_READING; mvd->dirty = qtrue; @@ -856,27 +884,28 @@ stop: } // ran out of buffers -static void gtv_wait_start( mvd_t *mvd ) { +static void gtv_wait_start(mvd_t *mvd) +{ gtv_t *gtv = mvd->gtv; int tr = mvd_wait_delay->value * 10; // if not connected, kill the channel - if( !gtv ) { - MVD_Destroyf( mvd, "End of MVD stream reached" ); + if (!gtv) { + MVD_Destroyf(mvd, "End of MVD stream reached"); } // FIXME: if connection is suspended, kill the channel - if( gtv->state != GTV_READING ) { - gtv_oob_kill( mvd ); + if (gtv->state != GTV_READING) { + gtv_oob_kill(mvd); } - Com_Printf( "[%s] -=- Buffering data...\n", mvd->name ); + Com_Printf("[%s] -=- Buffering data...\n", mvd->name); // oops, underflowed in the middle of the game, // resume as quickly as possible after there is some // data available again mvd->min_packets = 50 + 5 * mvd->underflows; - if( mvd->min_packets > tr ) { + if (mvd->min_packets > tr) { mvd->min_packets = tr; } mvd->underflows++; @@ -884,201 +913,209 @@ static void gtv_wait_start( mvd_t *mvd ) { mvd->dirty = qtrue; // notify spectators - if( Com_IsDedicated() ) { - MVD_BroadcastPrintf( mvd, PRINT_HIGH, 0, - "[MVD] Buffering data, please wait...\n" ); + if (Com_IsDedicated()) { + MVD_BroadcastPrintf(mvd, PRINT_HIGH, 0, + "[MVD] Buffering data, please wait...\n"); } // send ping to force server to flush - write_message( gtv, GTC_PING ); - NET_UpdateStream( >v->stream ); + write_message(gtv, GTC_PING); + NET_UpdateStream(>v->stream); } -static qboolean gtv_read_frame( mvd_t *mvd ) { +static qboolean gtv_read_frame(mvd_t *mvd) +{ uint16_t msglen; - switch( mvd->state ) { + switch (mvd->state) { case MVD_WAITING: - if( !gtv_wait_stop( mvd ) ) { + if (!gtv_wait_stop(mvd)) { return qfalse; } break; case MVD_READING: - if( !mvd->num_packets ) { - gtv_wait_start( mvd ); + if (!mvd->num_packets) { + gtv_wait_start(mvd); return qfalse; } break; default: - MVD_Destroyf( mvd, "%s: bad mvd->state", __func__ ); + MVD_Destroyf(mvd, "%s: bad mvd->state", __func__); } // NOTE: if we got here, delay buffer MUST contain // at least one complete, non-empty packet // parse msglen - if( FIFO_Read( &mvd->delay, &msglen, 2 ) != 2 ) { - MVD_Destroyf( mvd, "%s: partial data", __func__ ); + if (FIFO_Read(&mvd->delay, &msglen, 2) != 2) { + MVD_Destroyf(mvd, "%s: partial data", __func__); } - msglen = LittleShort( msglen ); - if( msglen < 1 || msglen > MAX_MSGLEN ) { - MVD_Destroyf( mvd, "%s: invalid msglen", __func__ ); + msglen = LittleShort(msglen); + if (msglen < 1 || msglen > MAX_MSGLEN) { + MVD_Destroyf(mvd, "%s: invalid msglen", __func__); } // read this message - if( !FIFO_ReadMessage( &mvd->delay, msglen ) ) { - MVD_Destroyf( mvd, "%s: partial data", __func__ ); + if (!FIFO_ReadMessage(&mvd->delay, msglen)) { + MVD_Destroyf(mvd, "%s: partial data", __func__); } // decrement buffered packets counter mvd->num_packets--; // parse it - MVD_ParseMessage( mvd ); + MVD_ParseMessage(mvd); return qtrue; } -static qboolean gtv_forward_cmd( mvd_client_t *client ) { +static qboolean gtv_forward_cmd(mvd_client_t *client) +{ mvd_t *mvd = client->mvd; gtv_t *gtv = mvd->gtv; char *text; size_t len; - if( !gtv || gtv->state < GTV_CONNECTED ) { - SV_ClientPrintf( client->cl, PRINT_HIGH, - "[MVD] Not connected to the game server.\n" ); + if (!gtv || gtv->state < GTV_CONNECTED) { + SV_ClientPrintf(client->cl, PRINT_HIGH, + "[MVD] Not connected to the game server.\n"); return qfalse; } - if( !( gtv->flags & GTF_STRINGCMDS ) ) { - SV_ClientPrintf( client->cl, PRINT_HIGH, - "[MVD] Game server does not allow command forwarding.\n" ); + if (!(gtv->flags & GTF_STRINGCMDS)) { + SV_ClientPrintf(client->cl, PRINT_HIGH, + "[MVD] Game server does not allow command forwarding.\n"); return qfalse; } - if( FIFO_Usage( >v->stream.send ) ) { - SV_ClientPrintf( client->cl, PRINT_HIGH, - "[MVD] Send buffer not empty, please wait.\n" ); + if (FIFO_Usage(>v->stream.send)) { + SV_ClientPrintf(client->cl, PRINT_HIGH, + "[MVD] Send buffer not empty, please wait.\n"); return qfalse; } text = Cmd_Args(); - len = strlen( text ); - if( len > 150 ) { + len = strlen(text); + if (len > 150) { len = 150; } // send it - MSG_WriteData( text, len ); - MSG_WriteByte( 0 ); - write_message( gtv, GTC_STRINGCMD ); - SZ_Clear( &msg_write ); - NET_UpdateStream( >v->stream ); + MSG_WriteData(text, len); + MSG_WriteByte(0); + write_message(gtv, GTC_STRINGCMD); + SZ_Clear(&msg_write); + NET_UpdateStream(>v->stream); return qtrue; } -static void send_hello( gtv_t *gtv ) { +static void send_hello(gtv_t *gtv) +{ int flags = GTF_STRINGCMDS; #if USE_ZLIB flags |= GTF_DEFLATE; #endif - MSG_WriteShort( GTV_PROTOCOL_VERSION ); - MSG_WriteLong( flags ); - MSG_WriteLong( 0 ); // reserved - MSG_WriteString( gtv->username ? gtv->username : mvd_username->string ); - MSG_WriteString( gtv->password ? gtv->password : mvd_password->string ); - MSG_WriteString( com_version->string ); - write_message( gtv, GTC_HELLO ); - SZ_Clear( &msg_write ); + MSG_WriteShort(GTV_PROTOCOL_VERSION); + MSG_WriteLong(flags); + MSG_WriteLong(0); // reserved + MSG_WriteString(gtv->username ? gtv->username : mvd_username->string); + MSG_WriteString(gtv->password ? gtv->password : mvd_password->string); + MSG_WriteString(com_version->string); + write_message(gtv, GTC_HELLO); + SZ_Clear(&msg_write); - Com_Printf( "[%s] -=- Sending client hello...\n", gtv->name ); + Com_Printf("[%s] -=- Sending client hello...\n", gtv->name); gtv->state = GTV_PREPARING; } -static void send_stream_start( gtv_t *gtv ) { +static void send_stream_start(gtv_t *gtv) +{ int maxbuf; - if( gtv->mvd ) { + if (gtv->mvd) { maxbuf = gtv->mvd->min_packets / 2; } else { maxbuf = mvd_wait_delay->value * 10 / 2; } - if( maxbuf < 10 ) { + if (maxbuf < 10) { maxbuf = 10; } // send stream start request - MSG_WriteShort( maxbuf ); - write_message( gtv, GTC_STREAM_START ); - SZ_Clear( &msg_write ); + MSG_WriteShort(maxbuf); + write_message(gtv, GTC_STREAM_START); + SZ_Clear(&msg_write); - Com_Printf( "[%s] -=- Sending stream start request...\n", gtv->name ); + Com_Printf("[%s] -=- Sending stream start request...\n", gtv->name); gtv->state = GTV_RESUMING; } -static void send_stream_stop( gtv_t *gtv ) { +static void send_stream_stop(gtv_t *gtv) +{ // send stream stop request - write_message( gtv, GTC_STREAM_STOP ); + write_message(gtv, GTC_STREAM_STOP); - Com_Printf( "[%s] -=- Sending stream stop request...\n", gtv->name ); + Com_Printf("[%s] -=- Sending stream stop request...\n", gtv->name); gtv->state = GTV_SUSPENDING; } #if USE_ZLIB -static voidpf gtv_zalloc OF(( voidpf opaque, uInt items, uInt size )) { - return MVD_Malloc( items * size ); +static voidpf gtv_zalloc OF((voidpf opaque, uInt items, uInt size)) +{ + return MVD_Malloc(items * size); } -static void gtv_zfree OF(( voidpf opaque, voidpf address )) { - Z_Free( address ); +static void gtv_zfree OF((voidpf opaque, voidpf address)) +{ + Z_Free(address); } #endif -static void parse_hello( gtv_t *gtv ) { +static void parse_hello(gtv_t *gtv) +{ int flags; - if( gtv->state >= GTV_CONNECTED ) { - gtv_destroyf( gtv, "Duplicated server hello" ); + if (gtv->state >= GTV_CONNECTED) { + gtv_destroyf(gtv, "Duplicated server hello"); } flags = MSG_ReadLong(); - if( flags & GTF_DEFLATE ) { + if (flags & GTF_DEFLATE) { #if USE_ZLIB - if( !gtv->z_str.state ) { + if (!gtv->z_str.state) { gtv->z_str.zalloc = gtv_zalloc; gtv->z_str.zfree = gtv_zfree; - if( inflateInit( >v->z_str ) != Z_OK ) { - gtv_destroyf( gtv, "inflateInit() failed: %s", - gtv->z_str.msg ); + if (inflateInit(>v->z_str) != Z_OK) { + gtv_destroyf(gtv, "inflateInit() failed: %s", + gtv->z_str.msg); } } - if( !gtv->z_buf.data ) { - gtv->z_buf.data = MVD_Malloc( MAX_GTS_MSGLEN ); + if (!gtv->z_buf.data) { + gtv->z_buf.data = MVD_Malloc(MAX_GTS_MSGLEN); gtv->z_buf.size = MAX_GTS_MSGLEN; } gtv->z_act = qtrue; // remaining data is deflated #else - gtv_destroyf( gtv, "Server sending deflated data" ); + gtv_destroyf(gtv, "Server sending deflated data"); #endif } - - Com_Printf( "[%s] -=- Server hello done.\n", gtv->name ); - if( sv.state != ss_broadcast ) { + Com_Printf("[%s] -=- Server hello done.\n", gtv->name); + + if (sv.state != ss_broadcast) { // the game is just starting - SV_InitGame( MVD_SPAWN_INTERNAL ); + SV_InitGame(MVD_SPAWN_INTERNAL); MVD_Spawn(); } else { // notify spectators - if( Com_IsDedicated() && gtv->mvd ) { - MVD_BroadcastPrintf( gtv->mvd, PRINT_HIGH, 0, - "[MVD] Restored connection to the game server!\n" ); + if (Com_IsDedicated() && gtv->mvd) { + MVD_BroadcastPrintf(gtv->mvd, PRINT_HIGH, 0, + "[MVD] Restored connection to the game server!\n"); } } @@ -1086,64 +1123,67 @@ static void parse_hello( gtv_t *gtv ) { gtv->state = GTV_CONNECTED; } -static void parse_stream_start( gtv_t *gtv ) { - if( gtv->state != GTV_RESUMING ) { - gtv_destroyf( gtv, "Unexpected stream start ack in state %u", gtv->state ); +static void parse_stream_start(gtv_t *gtv) +{ + if (gtv->state != GTV_RESUMING) { + gtv_destroyf(gtv, "Unexpected stream start ack in state %u", gtv->state); } - Com_Printf( "[%s] -=- Stream start ack received.\n", gtv->name ); + Com_Printf("[%s] -=- Stream start ack received.\n", gtv->name); gtv->state = GTV_READING; } -static void parse_stream_stop( gtv_t *gtv ) { - if( gtv->state != GTV_SUSPENDING ) { - gtv_destroyf( gtv, "Unexpected stream stop ack in state %u", gtv->state ); +static void parse_stream_stop(gtv_t *gtv) +{ + if (gtv->state != GTV_SUSPENDING) { + gtv_destroyf(gtv, "Unexpected stream stop ack in state %u", gtv->state); } - Com_Printf( "[%s] -=- Stream stop ack received.\n", gtv->name ); + Com_Printf("[%s] -=- Stream stop ack received.\n", gtv->name); gtv->state = GTV_CONNECTED; } -static void parse_stream_data( gtv_t *gtv ) { +static void parse_stream_data(gtv_t *gtv) +{ mvd_t *mvd = gtv->mvd; size_t size; - if( gtv->state < GTV_WAITING ) { - gtv_destroyf( gtv, "Unexpected stream data packet" ); + if (gtv->state < GTV_WAITING) { + gtv_destroyf(gtv, "Unexpected stream data packet"); } // ignore any pending data while suspending - if( gtv->state == GTV_SUSPENDING ) { + if (gtv->state == GTV_SUSPENDING) { msg_read.readcount = msg_read.cursize; return; } // empty data part acts as stream suspend marker - if( msg_read.readcount == msg_read.cursize ) { - if( gtv->state == GTV_READING ) { - Com_Printf( "[%s] -=- Stream suspended by server.\n", gtv->name ); + if (msg_read.readcount == msg_read.cursize) { + if (gtv->state == GTV_READING) { + Com_Printf("[%s] -=- Stream suspended by server.\n", gtv->name); gtv->state = GTV_WAITING; } return; } // non-empty data part acts as stream resume marker - if( gtv->state == GTV_WAITING ) { - Com_Printf( "[%s] -=- Stream resumed by server.\n", gtv->name ); + if (gtv->state == GTV_WAITING) { + Com_Printf("[%s] -=- Stream resumed by server.\n", gtv->name); gtv->state = GTV_READING; } // create the channel, if not yet created - if( !mvd ) { - mvd = create_channel( gtv ); + if (!mvd) { + mvd = create_channel(gtv); - Cvar_ClampInteger( mvd_buffer_size, 2, 10 ); + Cvar_ClampInteger(mvd_buffer_size, 2, 10); // allocate delay buffer size = mvd_buffer_size->integer * MAX_MSGLEN; - mvd->delay.data = MVD_Malloc( size ); + mvd->delay.data = MVD_Malloc(size); mvd->delay.size = size; mvd->read_frame = gtv_read_frame; mvd->forward_cmd = gtv_forward_cmd; @@ -1151,49 +1191,49 @@ static void parse_stream_data( gtv_t *gtv ) { gtv->mvd = mvd; } - if( !mvd->state ) { + if (!mvd->state) { // parse it in place until we get a gamestate - MVD_ParseMessage( mvd ); + MVD_ParseMessage(mvd); } else { byte *data = msg_read.data + 1; size_t len = msg_read.cursize - 1; uint16_t msglen; // see if this packet fits - if( FIFO_Write( &mvd->delay, NULL, len + 2 ) != len + 2 ) { - if( mvd->state == MVD_WAITING ) { + if (FIFO_Write(&mvd->delay, NULL, len + 2) != len + 2) { + if (mvd->state == MVD_WAITING) { // if delay buffer overflowed in waiting state, // something is seriously wrong, disconnect for safety - gtv_destroyf( gtv, "Delay buffer overflowed in waiting state" ); + gtv_destroyf(gtv, "Delay buffer overflowed in waiting state"); } // oops, overflowed - Com_Printf( "[%s] =!= Delay buffer overflowed!\n", gtv->name ); + Com_Printf("[%s] =!= Delay buffer overflowed!\n", gtv->name); - if( Com_IsDedicated() ) { + if (Com_IsDedicated()) { // notify spectators - MVD_BroadcastPrintf( mvd, PRINT_HIGH, 0, - "[MVD] Delay buffer overflowed!\n" ); + MVD_BroadcastPrintf(mvd, PRINT_HIGH, 0, + "[MVD] Delay buffer overflowed!\n"); } // clear entire delay buffer // minimize the delay - FIFO_Clear( &mvd->delay ); + FIFO_Clear(&mvd->delay); mvd->state = MVD_WAITING; mvd->num_packets = 0; mvd->min_packets = 50; mvd->overflows++; // send stream stop request - write_message( gtv, GTC_STREAM_STOP ); + write_message(gtv, GTC_STREAM_STOP); gtv->state = GTV_SUSPENDING; return; } // write it into delay buffer - msglen = LittleShort( len ); - FIFO_Write( &mvd->delay, &msglen, 2 ); - FIFO_Write( &mvd->delay, data, len ); + msglen = LittleShort(len); + FIFO_Write(&mvd->delay, &msglen, 2); + FIFO_Write(&mvd->delay, data, len); // increment buffered packets counter mvd->num_packets++; @@ -1202,41 +1242,42 @@ static void parse_stream_data( gtv_t *gtv ) { } } -static qboolean parse_message( gtv_t *gtv, fifo_t *fifo ) { +static qboolean parse_message(gtv_t *gtv, fifo_t *fifo) +{ uint32_t magic; uint16_t msglen; int cmd; // check magic - if( gtv->state < GTV_PREPARING ) { - if( !FIFO_TryRead( fifo, &magic, 4 ) ) { + if (gtv->state < GTV_PREPARING) { + if (!FIFO_TryRead(fifo, &magic, 4)) { return qfalse; } - if( magic != MVD_MAGIC ) { - gtv_destroyf( gtv, "Not a MVD/GTV stream" ); + if (magic != MVD_MAGIC) { + gtv_destroyf(gtv, "Not a MVD/GTV stream"); } // send client hello - send_hello( gtv ); + send_hello(gtv); } // parse msglen - if( !gtv->msglen ) { - if( !FIFO_TryRead( fifo, &msglen, 2 ) ) { + if (!gtv->msglen) { + if (!FIFO_TryRead(fifo, &msglen, 2)) { return qfalse; } - msglen = LittleShort( msglen ); - if( !msglen ) { - gtv_dropf( gtv, "End of MVD/GTV stream" ); + msglen = LittleShort(msglen); + if (!msglen) { + gtv_dropf(gtv, "End of MVD/GTV stream"); } - if( msglen > MAX_MSGLEN ) { - gtv_destroyf( gtv, "Oversize message" ); + if (msglen > MAX_MSGLEN) { + gtv_destroyf(gtv, "Oversize message"); } gtv->msglen = msglen; } // read this message - if( !FIFO_ReadMessage( fifo, gtv->msglen ) ) { + if (!FIFO_ReadMessage(fifo, gtv->msglen)) { return qfalse; } @@ -1244,111 +1285,114 @@ static qboolean parse_message( gtv_t *gtv, fifo_t *fifo ) { cmd = MSG_ReadByte(); - switch( cmd ) { + switch (cmd) { case GTS_HELLO: - parse_hello( gtv ); + parse_hello(gtv); break; case GTS_PONG: break; case GTS_STREAM_START: - parse_stream_start( gtv ); + parse_stream_start(gtv); break; case GTS_STREAM_STOP: - parse_stream_stop( gtv ); + parse_stream_stop(gtv); break; case GTS_STREAM_DATA: - parse_stream_data( gtv ); + parse_stream_data(gtv); break; case GTS_ERROR: - gtv_destroyf( gtv, "Server side error occured." ); + gtv_destroyf(gtv, "Server side error occured."); break; case GTS_BADREQUEST: - gtv_destroyf( gtv, "Server refused to process our request." ); + gtv_destroyf(gtv, "Server refused to process our request."); break; case GTS_NOACCESS: - gtv_destroyf( gtv, - "You don't have permission to access " - "MVD/GTV stream on this server." ); + gtv_destroyf(gtv, + "You don't have permission to access " + "MVD/GTV stream on this server."); break; case GTS_DISCONNECT: - gtv_destroyf( gtv, "Server has been shut down." ); + gtv_destroyf(gtv, "Server has been shut down."); break; case GTS_RECONNECT: - gtv_dropf( gtv, "Server has been restarted." ); + gtv_dropf(gtv, "Server has been restarted."); break; default: - gtv_destroyf( gtv, "Unknown command byte" ); + gtv_destroyf(gtv, "Unknown command byte"); } - if( msg_read.readcount > msg_read.cursize ) { - gtv_destroyf( gtv, "Read past end of message" ); + if (msg_read.readcount > msg_read.cursize) { + gtv_destroyf(gtv, "Read past end of message"); } - + gtv->last_rcvd = svs.realtime; // don't timeout return qtrue; } #if USE_ZLIB -static int inflate_stream( fifo_t *dst, fifo_t *src, z_streamp z ) { +static int inflate_stream(fifo_t *dst, fifo_t *src, z_streamp z) +{ byte *data; size_t avail_in, avail_out; int ret = Z_BUF_ERROR; do { - data = FIFO_Peek( src, &avail_in ); - if( !avail_in ) { + data = FIFO_Peek(src, &avail_in); + if (!avail_in) { break; } z->next_in = data; - z->avail_in = ( uInt )avail_in; + z->avail_in = (uInt)avail_in; - data = FIFO_Reserve( dst, &avail_out ); - if( !avail_out ) { + data = FIFO_Reserve(dst, &avail_out); + if (!avail_out) { break; } z->next_out = data; - z->avail_out = ( uInt )avail_out; + z->avail_out = (uInt)avail_out; - ret = inflate( z, Z_SYNC_FLUSH ); + ret = inflate(z, Z_SYNC_FLUSH); - FIFO_Decommit( src, avail_in - z->avail_in ); - FIFO_Commit( dst, avail_out - z->avail_out ); - } while( ret == Z_OK ); + FIFO_Decommit(src, avail_in - z->avail_in); + FIFO_Commit(dst, avail_out - z->avail_out); + } while (ret == Z_OK); return ret; } -static void inflate_more( gtv_t *gtv ) { - int ret = inflate_stream( >v->z_buf, >v->stream.recv, >v->z_str ); +static void inflate_more(gtv_t *gtv) +{ + int ret = inflate_stream(>v->z_buf, >v->stream.recv, >v->z_str); - switch( ret ) { + switch (ret) { case Z_BUF_ERROR: case Z_OK: break; case Z_STREAM_END: - inflateReset( >v->z_str ); + inflateReset(>v->z_str); gtv->z_act = qfalse; break; default: - gtv_destroyf( gtv, "inflate() failed: %s", gtv->z_str.msg ); + gtv_destroyf(gtv, "inflate() failed: %s", gtv->z_str.msg); } } #endif -static neterr_t run_connect( gtv_t *gtv ) { +static neterr_t run_connect(gtv_t *gtv) +{ neterr_t ret; uint32_t magic; // run connection - if( ( ret = NET_RunConnect( >v->stream ) ) != NET_OK ) { + if ((ret = NET_RunConnect(>v->stream)) != NET_OK) { return ret; } - Com_Printf( "[%s] -=- Connected to the game server!\n", gtv->name ); + Com_Printf("[%s] -=- Connected to the game server!\n", gtv->name); // allocate buffers - if( !gtv->data ) { - gtv->data = MVD_Malloc( MAX_GTS_MSGLEN + MAX_GTC_MSGLEN ); + if (!gtv->data) { + gtv->data = MVD_Malloc(MAX_GTS_MSGLEN + MAX_GTC_MSGLEN); } gtv->stream.recv.data = gtv->data; gtv->stream.recv.size = MAX_GTS_MSGLEN; @@ -1360,12 +1404,13 @@ static neterr_t run_connect( gtv_t *gtv ) { // send magic magic = MVD_MAGIC; - write_stream( gtv, &magic, 4 ); + write_stream(gtv, &magic, 4); return NET_OK; } -static neterr_t run_stream( gtv_t *gtv ) { +static neterr_t run_stream(gtv_t *gtv) +{ neterr_t ret; #ifdef _DEBUG int count; @@ -1373,23 +1418,23 @@ static neterr_t run_stream( gtv_t *gtv ) { #endif // run network stream - if( ( ret = NET_RunStream( >v->stream ) ) != NET_OK ) { + if ((ret = NET_RunStream(>v->stream)) != NET_OK) { return ret; } #ifdef _DEBUG count = 0; - usage = FIFO_Usage( >v->stream.recv ); + usage = FIFO_Usage(>v->stream.recv); #endif #if USE_ZLIB - if( gtv->z_act ) { - while( 1 ) { + if (gtv->z_act) { + while (1) { // decompress more data - if( gtv->z_act ) { - inflate_more( gtv ); + if (gtv->z_act) { + inflate_more(gtv); } - if( !parse_message( gtv, >v->z_buf ) ) { + if (!parse_message(gtv, >v->z_buf)) { break; } #ifdef _DEBUG @@ -1398,186 +1443,191 @@ static neterr_t run_stream( gtv_t *gtv ) { } } else #endif - while( parse_message( gtv, >v->stream.recv ) ) { + while (parse_message(gtv, >v->stream.recv)) { #ifdef _DEBUG count++; #endif } #ifdef _DEBUG - if( mvd_shownet->integer == -1 ) { - size_t total = usage - FIFO_Usage( >v->stream.recv ); + if (mvd_shownet->integer == -1) { + size_t total = usage - FIFO_Usage(>v->stream.recv); - Com_Printf( "[%s] %"PRIz" bytes, %d msgs\n", - gtv->name, total, count ); + Com_Printf("[%s] %"PRIz" bytes, %d msgs\n", + gtv->name, total, count); } #endif return NET_OK; } -static void check_timeouts( gtv_t *gtv ) { +static void check_timeouts(gtv_t *gtv) +{ unsigned timeout = mvd_timeout->value * 1000; // drop if no data has been received for too long - if( svs.realtime - gtv->last_rcvd > timeout ) { - gtv_dropf( gtv, "Server connection timed out." ); + if (svs.realtime - gtv->last_rcvd > timeout) { + gtv_dropf(gtv, "Server connection timed out."); } - if( gtv->state < GTV_CONNECTED ) { + if (gtv->state < GTV_CONNECTED) { return; } // stop/start stream depending on global state - if( mvd_active ) { - if( gtv->state == GTV_CONNECTED ) { - send_stream_start( gtv ); + if (mvd_active) { + if (gtv->state == GTV_CONNECTED) { + send_stream_start(gtv); } - } else if( gtv->state == GTV_WAITING || gtv->state == GTV_READING ) { - send_stream_stop( gtv ); + } else if (gtv->state == GTV_WAITING || gtv->state == GTV_READING) { + send_stream_stop(gtv); } // ping if no data has been sent for too long - if( svs.realtime - gtv->last_sent > GTV_PING_INTERVAL ) { - write_message( gtv, GTC_PING ); + if (svs.realtime - gtv->last_sent > GTV_PING_INTERVAL) { + write_message(gtv, GTC_PING); } } -static qboolean check_reconnect( gtv_t *gtv ) { +static qboolean check_reconnect(gtv_t *gtv) +{ netadr_t adr; - if( svs.realtime - gtv->retry_time < gtv->retry_backoff ) { + if (svs.realtime - gtv->retry_time < gtv->retry_backoff) { return qfalse; } - Com_Printf( "[%s] -=- Attempting to reconnect to %s...\n", - gtv->name, gtv->address ); + Com_Printf("[%s] -=- Attempting to reconnect to %s...\n", + gtv->name, gtv->address); gtv->state = GTV_CONNECTING; // don't timeout gtv->last_sent = gtv->last_rcvd = svs.realtime; - if( !NET_StringToAdr( gtv->address, &adr, PORT_SERVER ) ) { - gtv_dropf( gtv, "Unable to lookup %s\n", gtv->address ); + if (!NET_StringToAdr(gtv->address, &adr, PORT_SERVER)) { + gtv_dropf(gtv, "Unable to lookup %s\n", gtv->address); } - if( NET_Connect( &adr, >v->stream ) == NET_ERROR ) { - gtv_dropf( gtv, "%s to %s\n", NET_ErrorString(), - NET_AdrToString( &adr ) ); + if (NET_Connect(&adr, >v->stream) == NET_ERROR) { + gtv_dropf(gtv, "%s to %s\n", NET_ErrorString(), + NET_AdrToString(&adr)); } return qtrue; } -static void gtv_run( gtv_t *gtv ) { +static void gtv_run(gtv_t *gtv) +{ neterr_t ret = NET_AGAIN; // check if it is time to reconnect - if( !gtv->state ) { - if( !check_reconnect( gtv ) ) { + if (!gtv->state) { + if (!check_reconnect(gtv)) { return; } } // run network stream - switch( gtv->stream.state ) { + switch (gtv->stream.state) { case NS_CONNECTING: - ret = run_connect( gtv ); - if( ret == NET_AGAIN ) { + ret = run_connect(gtv); + if (ret == NET_AGAIN) { return; } - if( ret == NET_OK ) { - case NS_CONNECTED: - ret = run_stream( gtv ); + if (ret == NET_OK) { + case NS_CONNECTED: + ret = run_stream(gtv); } break; default: return; } - switch( ret ) { + switch (ret) { case NET_AGAIN: case NET_OK: - check_timeouts( gtv ); - NET_UpdateStream( >v->stream ); + check_timeouts(gtv); + NET_UpdateStream(>v->stream); break; case NET_ERROR: - gtv_dropf( gtv, "%s to %s", NET_ErrorString(), - NET_AdrToString( >v->stream.address ) ); + gtv_dropf(gtv, "%s to %s", NET_ErrorString(), + NET_AdrToString(>v->stream.address)); break; case NET_CLOSED: - gtv_dropf( gtv, "Server has closed connection." ); + gtv_dropf(gtv, "Server has closed connection."); break; } } -static void gtv_destroy( gtv_t *gtv ) { +static void gtv_destroy(gtv_t *gtv) +{ mvd_t *mvd = gtv->mvd; // drop any associated MVD channel - if( mvd ) { + if (mvd) { mvd->gtv = NULL; // don't double destroy - if( !mvd->state ) { + if (!mvd->state) { // free it here, since it is not yet // added to global channel list - MVD_Free( mvd ); - } else if( Com_IsDedicated() ) { + MVD_Free(mvd); + } else if (Com_IsDedicated()) { // notify spectators - MVD_BroadcastPrintf( mvd, PRINT_HIGH, 0, - "[MVD] Disconnected from the game server!\n" ); + MVD_BroadcastPrintf(mvd, PRINT_HIGH, 0, + "[MVD] Disconnected from the game server!\n"); } } // make sure network connection is closed - NET_Close( >v->stream ); + NET_Close(>v->stream); // unlink from the list of connections - List_Remove( >v->entry ); + List_Remove(>v->entry); // free all memory buffers - Z_Free( gtv->username ); - Z_Free( gtv->password ); + Z_Free(gtv->username); + Z_Free(gtv->password); #if USE_ZLIB - inflateEnd( >v->z_str ); - Z_Free( gtv->z_buf.data ); + inflateEnd(>v->z_str); + Z_Free(gtv->z_buf.data); #endif - Z_Free( gtv->data ); - Z_Free( gtv ); + Z_Free(gtv->data); + Z_Free(gtv); } -static void gtv_drop( gtv_t *gtv ) { +static void gtv_drop(gtv_t *gtv) +{ time_t sec; char buffer[MAX_QPATH]; - if( gtv->stream.state < NS_CONNECTED ) { - gtv->retry_backoff += 15*1000; + if (gtv->stream.state < NS_CONNECTED) { + gtv->retry_backoff += 15 * 1000; } else { // notify spectators - if( Com_IsDedicated() && gtv->mvd ) { - MVD_BroadcastPrintf( gtv->mvd, PRINT_HIGH, 0, - "[MVD] Lost connection to the game server!\n" ); + if (Com_IsDedicated() && gtv->mvd) { + MVD_BroadcastPrintf(gtv->mvd, PRINT_HIGH, 0, + "[MVD] Lost connection to the game server!\n"); } - if( gtv->state >= GTV_CONNECTED ) { + if (gtv->state >= GTV_CONNECTED) { gtv->retry_backoff = GTV_DEFAULT_BACKOFF; } else { - gtv->retry_backoff += 30*1000; + gtv->retry_backoff += 30 * 1000; } } - if( gtv->retry_backoff > GTV_MAXIMUM_BACKOFF ) { + if (gtv->retry_backoff > GTV_MAXIMUM_BACKOFF) { gtv->retry_backoff = GTV_MAXIMUM_BACKOFF; } sec = gtv->retry_backoff / 1000; - Com_FormatTimeLong( buffer, sizeof( buffer ), sec ); - Com_Printf( "[%s] -=- Reconnecting in %s.\n", gtv->name, buffer ); + Com_FormatTimeLong(buffer, sizeof(buffer), sec); + Com_Printf("[%s] -=- Reconnecting in %s.\n", gtv->name, buffer); - NET_Close( >v->stream ); + NET_Close(>v->stream); #if USE_ZLIB - inflateReset( >v->z_str ); - FIFO_Clear( >v->z_buf ); + inflateReset(>v->z_str); + FIFO_Clear(>v->z_buf); gtv->z_act = qfalse; #endif gtv->msglen = 0; @@ -1594,18 +1644,19 @@ OPERATOR COMMANDS ==================================================================== */ -void MVD_Spawn( void ) { - Cvar_SetInteger( sv_running, ss_broadcast, FROM_CODE ); - Cvar_Set( "sv_paused", "0" ); - Cvar_Set( "timedemo", "0" ); - SV_InfoSet( "port", net_port->string ); +void MVD_Spawn(void) +{ + Cvar_SetInteger(sv_running, ss_broadcast, FROM_CODE); + Cvar_Set("sv_paused", "0"); + Cvar_Set("timedemo", "0"); + SV_InfoSet("port", net_port->string); #if USE_SYSCON SV_SetConsoleTitle(); #endif // generate spawncount for Waiting Room - sv.spawncount = ( rand() | ( rand() << 16 ) ) ^ Sys_Milliseconds(); + sv.spawncount = (rand() | (rand() << 16)) ^ Sys_Milliseconds(); sv.spawncount &= 0x7FFFFFFF; #if USE_FPS @@ -1618,166 +1669,176 @@ void MVD_Spawn( void ) { sv.state = ss_broadcast; } -static void MVD_Spawn_f( void ) { - SV_InitGame( MVD_SPAWN_ENABLED ); +static void MVD_Spawn_f(void) +{ + SV_InitGame(MVD_SPAWN_ENABLED); MVD_Spawn(); } -static void list_generic( void ) { +static void list_generic(void) +{ mvd_t *mvd; Com_Printf( "id name map spc plr stat buf pckt address \n" - "-- ------------ -------- --- --- ---- --- ---- --------------\n" ); + "-- ------------ -------- --- --- ---- --- ---- --------------\n"); - FOR_EACH_MVD( mvd ) { - Com_Printf( "%2d %-12.12s %-8.8s %3d %3d %-4.4s %3d %4u %s\n", - mvd->id, mvd->name, mvd->mapname, - List_Count( &mvd->clients ), mvd->numplayers, - mvd_states[mvd->state], - FIFO_Percent( &mvd->delay ), mvd->num_packets, - mvd->gtv ? mvd->gtv->address : "<disconnected>" ); + FOR_EACH_MVD(mvd) { + Com_Printf("%2d %-12.12s %-8.8s %3d %3d %-4.4s %3d %4u %s\n", + mvd->id, mvd->name, mvd->mapname, + List_Count(&mvd->clients), mvd->numplayers, + mvd_states[mvd->state], + FIFO_Percent(&mvd->delay), mvd->num_packets, + mvd->gtv ? mvd->gtv->address : "<disconnected>"); } } -static void list_recordings( void ) { +static void list_recordings(void) +{ mvd_t *mvd; char buffer[8]; off_t pos; Com_Printf( "id name map size name\n" - "-- ------------ -------- ---- --------------\n" ); + "-- ------------ -------- ---- --------------\n"); - FOR_EACH_MVD( mvd ) { - if( mvd->demorecording ) { - pos = FS_Tell( mvd->demorecording ); - Com_FormatSize( buffer, sizeof( buffer ), pos ); + FOR_EACH_MVD(mvd) { + if (mvd->demorecording) { + pos = FS_Tell(mvd->demorecording); + Com_FormatSize(buffer, sizeof(buffer), pos); } else { - strcpy( buffer, "-" ); + strcpy(buffer, "-"); } - Com_Printf( "%2d %-12.12s %-8.8s %-4s %s\n", - mvd->id, mvd->name, mvd->mapname, - buffer, mvd->demoname ? mvd->demoname : "-" ); + Com_Printf("%2d %-12.12s %-8.8s %-4s %s\n", + mvd->id, mvd->name, mvd->mapname, + buffer, mvd->demoname ? mvd->demoname : "-"); } } -static void MVD_ListChannels_f( void ) { +static void MVD_ListChannels_f(void) +{ char *s; - if( LIST_EMPTY( &mvd_channel_list ) ) { - Com_Printf( "No MVD channels.\n" ); + if (LIST_EMPTY(&mvd_channel_list)) { + Com_Printf("No MVD channels.\n"); return; } - s = Cmd_Argv( 1 ); - if( *s == 'r' ) { + s = Cmd_Argv(1); + if (*s == 'r') { list_recordings(); } else { list_generic(); } } -static void MVD_ListServers_f( void ) { +static void MVD_ListServers_f(void) +{ gtv_t *gtv; unsigned ratio; - if( LIST_EMPTY( &mvd_gtv_list ) ) { - Com_Printf( "No GTV connections.\n" ); + if (LIST_EMPTY(&mvd_gtv_list)) { + Com_Printf("No GTV connections.\n"); return; } Com_Printf( "id name state ratio lastmsg address \n" - "-- ------------ ------------ ----- ------- --------------\n" ); + "-- ------------ ------------ ----- ------- --------------\n"); - FOR_EACH_GTV( gtv ) { + FOR_EACH_GTV(gtv) { ratio = 100; #if USE_ZLIB - if( gtv->z_act && gtv->z_str.total_out ) { - ratio = 100 * ( ( double )gtv->z_str.total_in / - gtv->z_str.total_out ); + if (gtv->z_act && gtv->z_str.total_out) { + ratio = 100 * ((double)gtv->z_str.total_in / + gtv->z_str.total_out); } #endif - Com_Printf( "%2d %-12.12s %-12.12s %4u%% %7u %s\n", - gtv->id, gtv->name, gtv_states[gtv->state], - ratio, svs.realtime - gtv->last_rcvd, - NET_AdrToString( >v->stream.address ) ); + Com_Printf("%2d %-12.12s %-12.12s %4u%% %7u %s\n", + gtv->id, gtv->name, gtv_states[gtv->state], + ratio, svs.realtime - gtv->last_rcvd, + NET_AdrToString(>v->stream.address)); } } -void MVD_StreamedStop_f( void ) { +void MVD_StreamedStop_f(void) +{ mvd_t *mvd; - mvd = MVD_SetChannel( 1 ); - if( !mvd ) { - Com_Printf( "Usage: %s [chanid]\n", Cmd_Argv( 0 ) ); + mvd = MVD_SetChannel(1); + if (!mvd) { + Com_Printf("Usage: %s [chanid]\n", Cmd_Argv(0)); return; } - if( !mvd->demorecording ) { - Com_Printf( "[%s] Not recording a demo.\n", mvd->name ); + if (!mvd->demorecording) { + Com_Printf("[%s] Not recording a demo.\n", mvd->name); return; } - MVD_StopRecord( mvd ); + MVD_StopRecord(mvd); - Com_Printf( "[%s] Stopped recording.\n", mvd->name ); + Com_Printf("[%s] Stopped recording.\n", mvd->name); } -static inline int player_flags( mvd_t *mvd, mvd_player_t *player ) { +static inline int player_flags(mvd_t *mvd, mvd_player_t *player) +{ int flags = 0; - if( !player->inuse ) + if (!player->inuse) flags |= MSG_PS_REMOVE; return flags; } -static inline int entity_flags( mvd_t *mvd, edict_t *ent ) { +static inline int entity_flags(mvd_t *mvd, edict_t *ent) +{ int flags = MSG_ES_UMASK; - if( !ent->inuse ) { + if (!ent->inuse) { flags |= MSG_ES_REMOVE; - } else if( ent->s.number <= mvd->maxclients ) { - mvd_player_t *player = &mvd->players[ ent->s.number - 1 ]; - if( player->inuse && player->ps.pmove.pm_type == PM_NORMAL ) + } else if (ent->s.number <= mvd->maxclients) { + mvd_player_t *player = &mvd->players[ent->s.number - 1]; + if (player->inuse && player->ps.pmove.pm_type == PM_NORMAL) flags |= MSG_ES_FIRSTPERSON; } return flags; } -static void emit_base_frame( mvd_t *mvd ) { +static void emit_base_frame(mvd_t *mvd) +{ edict_t *ent; mvd_player_t *player; int i, portalbytes; byte portalbits[MAX_MAP_PORTAL_BYTES]; - portalbytes = CM_WritePortalBits( &mvd->cm, portalbits ); - MSG_WriteByte( portalbytes ); - MSG_WriteData( portalbits, portalbytes ); + portalbytes = CM_WritePortalBits(&mvd->cm, portalbits); + MSG_WriteByte(portalbytes); + MSG_WriteData(portalbits, portalbytes); // send base player states - for( i = 0; i < mvd->maxclients; i++ ) { + for (i = 0; i < mvd->maxclients; i++) { player = &mvd->players[i]; - MSG_WriteDeltaPlayerstate_Packet( NULL, &player->ps, i, - player_flags( mvd, player ) ); + MSG_WriteDeltaPlayerstate_Packet(NULL, &player->ps, i, + player_flags(mvd, player)); } - MSG_WriteByte( CLIENTNUM_NONE ); + MSG_WriteByte(CLIENTNUM_NONE); // send base entity states - for( i = 1; i < mvd->pool.num_edicts; i++ ) { + for (i = 1; i < mvd->pool.num_edicts; i++) { ent = &mvd->edicts[i]; ent->s.number = i; - MSG_WriteDeltaEntity( NULL, &ent->s, entity_flags( mvd, ent ) ); + MSG_WriteDeltaEntity(NULL, &ent->s, entity_flags(mvd, ent)); } - MSG_WriteShort( 0 ); + MSG_WriteShort(0); } -static void emit_gamestate( mvd_t *mvd ) { +static void emit_gamestate(mvd_t *mvd) +{ int i, extra; char *s; size_t len; @@ -1786,37 +1847,38 @@ static void emit_gamestate( mvd_t *mvd ) { extra = mvd->flags << SVCMD_BITS; // send the serverdata - MSG_WriteByte( mvd_serverdata | extra ); - MSG_WriteLong( PROTOCOL_VERSION_MVD ); - MSG_WriteShort( PROTOCOL_VERSION_MVD_CURRENT ); - MSG_WriteLong( mvd->servercount ); - MSG_WriteString( mvd->gamedir ); - MSG_WriteShort( mvd->clientNum ); + MSG_WriteByte(mvd_serverdata | extra); + MSG_WriteLong(PROTOCOL_VERSION_MVD); + MSG_WriteShort(PROTOCOL_VERSION_MVD_CURRENT); + MSG_WriteLong(mvd->servercount); + MSG_WriteString(mvd->gamedir); + MSG_WriteShort(mvd->clientNum); // send configstrings - for( i = 0; i < MAX_CONFIGSTRINGS; i++ ) { + for (i = 0; i < MAX_CONFIGSTRINGS; i++) { s = mvd->configstrings[i]; - if( !*s ) + if (!*s) continue; - len = strlen( s ); - if( len > MAX_QPATH ) + len = strlen(s); + if (len > MAX_QPATH) len = MAX_QPATH; - MSG_WriteShort( i ); - MSG_WriteData( s, len ); - MSG_WriteByte( 0 ); + MSG_WriteShort(i); + MSG_WriteData(s, len); + MSG_WriteByte(0); } - MSG_WriteShort( MAX_CONFIGSTRINGS ); + MSG_WriteShort(MAX_CONFIGSTRINGS); // send baseline frame - emit_base_frame( mvd ); + emit_base_frame(mvd); // TODO: write private layouts/configstrings } -void MVD_StreamedRecord_f( void ) { +void MVD_StreamedRecord_f(void) +{ char buffer[MAX_OSPATH]; qhandle_t f; mvd_t *mvd; @@ -1826,12 +1888,12 @@ void MVD_StreamedRecord_f( void ) { ssize_t ret; int c; - while( ( c = Cmd_ParseOptions( o_record ) ) != -1 ) { - switch( c ) { + while ((c = Cmd_ParseOptions(o_record)) != -1) { + switch (c) { case 'h': - Cmd_PrintUsage( o_record, "<filename> [chanid]" ); - Com_Printf( "Begin MVD recording on the specified channel.\n" ); - Cmd_PrintHelp( o_record ); + Cmd_PrintUsage(o_record, "<filename> [chanid]"); + Com_Printf("Begin MVD recording on the specified channel.\n"); + Cmd_PrintHelp(o_record); return; case 'z': mode |= FS_FLAG_GZIP; @@ -1841,61 +1903,61 @@ void MVD_StreamedRecord_f( void ) { } } - if( !cmd_optarg[0] ) { - Com_Printf( "Missing filename argument.\n" ); + if (!cmd_optarg[0]) { + Com_Printf("Missing filename argument.\n"); Cmd_PrintHint(); return; } - - if( ( mvd = MVD_SetChannel( cmd_optind + 1 ) ) == NULL ) { + + if ((mvd = MVD_SetChannel(cmd_optind + 1)) == NULL) { Cmd_PrintHint(); return; } - if( mvd->demorecording ) { - Com_Printf( "[%s] Already recording into %s.\n", - mvd->name, mvd->demoname ); + if (mvd->demorecording) { + Com_Printf("[%s] Already recording into %s.\n", + mvd->name, mvd->demoname); return; } // // open the demo file // - f = FS_EasyOpenFile( buffer, sizeof( buffer ), mode, - "demos/", cmd_optarg, ".mvd2" ); - if( !f ) { + f = FS_EasyOpenFile(buffer, sizeof(buffer), mode, + "demos/", cmd_optarg, ".mvd2"); + if (!f) { return; } - Com_Printf( "[%s] Recording into %s\n", mvd->name, buffer ); + Com_Printf("[%s] Recording into %s\n", mvd->name, buffer); mvd->demorecording = f; - mvd->demoname = MVD_CopyString( buffer ); + mvd->demoname = MVD_CopyString(buffer); - emit_gamestate( mvd ); + emit_gamestate(mvd); // write magic magic = MVD_MAGIC; - ret = FS_Write( &magic, 4, f ); - if( ret != 4 ) + ret = FS_Write(&magic, 4, f); + if (ret != 4) goto fail; // write gamestate - msglen = LittleShort( msg_write.cursize ); - ret = FS_Write( &msglen, 2, f ); - if( ret != 2 ) + msglen = LittleShort(msg_write.cursize); + ret = FS_Write(&msglen, 2, f); + if (ret != 2) goto fail; - ret = FS_Write( msg_write.data, msg_write.cursize, f ); - if( ret != msg_write.cursize ) + ret = FS_Write(msg_write.data, msg_write.cursize, f); + if (ret != msg_write.cursize) goto fail; - SZ_Clear( &msg_write ); + SZ_Clear(&msg_write); return; fail: - SZ_Clear( &msg_write ); - Com_EPrintf( "[%s] Couldn't write demo: %s\n", mvd->name, Q_ErrorString( ret ) ); - MVD_StopRecord( mvd ); + SZ_Clear(&msg_write); + Com_EPrintf("[%s] Couldn't write demo: %s\n", mvd->name, Q_ErrorString(ret)); + MVD_StopRecord(mvd); } static const cmd_option_t o_mvdconnect[] = { @@ -1906,8 +1968,9 @@ static const cmd_option_t o_mvdconnect[] = { { NULL } }; -static void MVD_Connect_c( genctx_t *ctx, int argnum ) { - Cmd_Option_c( o_mvdconnect, Com_Address_g, ctx, argnum ); +static void MVD_Connect_c(genctx_t *ctx, int argnum) +{ + Cmd_Option_c(o_mvdconnect, Com_Address_g, ctx, argnum); } /* @@ -1915,19 +1978,20 @@ static void MVD_Connect_c( genctx_t *ctx, int argnum ) { MVD_Connect_f ============== */ -static void MVD_Connect_f( void ) { +static void MVD_Connect_f(void) +{ netadr_t adr; netstream_t stream; char *name = NULL, *username = NULL, *password = NULL; gtv_t *gtv; int c; - while( ( c = Cmd_ParseOptions( o_mvdconnect ) ) != -1 ) { - switch( c ) { + while ((c = Cmd_ParseOptions(o_mvdconnect)) != -1) { + switch (c) { case 'h': - Cmd_PrintUsage( o_mvdconnect, "<address[:port]>" ); - Com_Printf( "Connect to the specified MVD/GTV server.\n" ); - Cmd_PrintHelp( o_mvdconnect ); + Cmd_PrintUsage(o_mvdconnect, "<address[:port]>"); + Com_Printf("Connect to the specified MVD/GTV server.\n"); + Cmd_PrintHelp(o_mvdconnect); return; case 'n': name = cmd_optarg; @@ -1943,36 +2007,36 @@ static void MVD_Connect_f( void ) { } } - if( !cmd_optarg[0] ) { - Com_Printf( "Missing address argument.\n" ); + if (!cmd_optarg[0]) { + Com_Printf("Missing address argument.\n"); Cmd_PrintHint(); return; } // resolve hostname - if( !NET_StringToAdr( cmd_optarg, &adr, PORT_SERVER ) ) { - Com_Printf( "Bad server address: %s\n", cmd_optarg ); + if (!NET_StringToAdr(cmd_optarg, &adr, PORT_SERVER)) { + Com_Printf("Bad server address: %s\n", cmd_optarg); return; } // don't allow multiple connections - FOR_EACH_GTV( gtv ) { - if( NET_IsEqualAdr( &adr, >v->stream.address ) ) { - Com_Printf( "[%s] =!= Connection to %s already exists.\n", - gtv->name, NET_AdrToString( &adr ) ); + FOR_EACH_GTV(gtv) { + if (NET_IsEqualAdr(&adr, >v->stream.address)) { + Com_Printf("[%s] =!= Connection to %s already exists.\n", + gtv->name, NET_AdrToString(&adr)); return; } } // create new socket and start connecting - if( NET_Connect( &adr, &stream ) == NET_ERROR ) { - Com_EPrintf( "%s to %s\n", NET_ErrorString(), - NET_AdrToString( &adr ) ); + if (NET_Connect(&adr, &stream) == NET_ERROR) { + Com_EPrintf("%s to %s\n", NET_ErrorString(), + NET_AdrToString(&adr)); return; } // create new connection - gtv = MVD_Mallocz( sizeof( *gtv ) ); + gtv = MVD_Mallocz(sizeof(*gtv)); gtv->id = mvd_chanid++; gtv->state = GTV_CONNECTING; gtv->stream = stream; @@ -1980,67 +2044,70 @@ static void MVD_Connect_f( void ) { gtv->run = gtv_run; gtv->drop = gtv_drop; gtv->destroy = gtv_destroy; - gtv->username = MVD_CopyString( username ); - gtv->password = MVD_CopyString( password ); - List_Append( &mvd_gtv_list, >v->entry ); + gtv->username = MVD_CopyString(username); + gtv->password = MVD_CopyString(password); + List_Append(&mvd_gtv_list, >v->entry); // set channel name - if( name ) { - Q_strlcpy( gtv->name, name, sizeof( gtv->name ) ); + if (name) { + Q_strlcpy(gtv->name, name, sizeof(gtv->name)); } else { - Q_snprintf( gtv->name, sizeof( gtv->name ), "net%d", gtv->id ); + Q_snprintf(gtv->name, sizeof(gtv->name), "net%d", gtv->id); } - Q_strlcpy( gtv->address, cmd_optarg, sizeof( gtv->address ) ); + Q_strlcpy(gtv->address, cmd_optarg, sizeof(gtv->address)); - Com_Printf( "[%s] -=- Connecting to %s...\n", - gtv->name, NET_AdrToString( &adr ) ); + Com_Printf("[%s] -=- Connecting to %s...\n", + gtv->name, NET_AdrToString(&adr)); } -static void MVD_Disconnect_f( void ) { +static void MVD_Disconnect_f(void) +{ gtv_t *gtv; - gtv = gtv_set_conn( 1 ); - if( !gtv ) { + gtv = gtv_set_conn(1); + if (!gtv) { return; } - Com_Printf( "[%s] =X= Connection destroyed.\n", gtv->name ); - gtv->destroy( gtv ); + Com_Printf("[%s] =X= Connection destroyed.\n", gtv->name); + gtv->destroy(gtv); } -static void MVD_Kill_f( void ) { +static void MVD_Kill_f(void) +{ mvd_t *mvd; - mvd = MVD_SetChannel( 1 ); - if( !mvd ) { + mvd = MVD_SetChannel(1); + if (!mvd) { return; } - Com_Printf( "[%s] =X= Channel was killed.\n", mvd->name ); - MVD_Destroy( mvd ); + Com_Printf("[%s] =X= Channel was killed.\n", mvd->name); + MVD_Destroy(mvd); } -static void MVD_Pause_f( void ) { +static void MVD_Pause_f(void) +{ mvd_t *mvd; - mvd = MVD_SetChannel( 1 ); - if( !mvd ) { + mvd = MVD_SetChannel(1); + if (!mvd) { return; } - if( !mvd->gtv || !mvd->gtv->demoplayback ) { - Com_Printf( "[%s] Only demo channels can be paused.\n", mvd->name ); + if (!mvd->gtv || !mvd->gtv->demoplayback) { + Com_Printf("[%s] Only demo channels can be paused.\n", mvd->name); return; } - switch( mvd->state ) { + switch (mvd->state) { case MVD_WAITING: - //Com_Printf( "[%s] Channel was resumed.\n", mvd->name ); + //Com_Printf("[%s] Channel was resumed.\n", mvd->name); mvd->state = MVD_READING; break; case MVD_READING: - //Com_Printf( "[%s] Channel was paused.\n", mvd->name ); + //Com_Printf("[%s] Channel was paused.\n", mvd->name); mvd->state = MVD_WAITING; break; default: @@ -2048,30 +2115,32 @@ static void MVD_Pause_f( void ) { } } -static void MVD_Skip_f( void ) { +static void MVD_Skip_f(void) +{ mvd_t *mvd; int count; - mvd = MVD_SetChannel( 1 ); - if( !mvd ) { - Com_Printf( "Usage: %s [chan_id] [count]\n", Cmd_Argv( 0 ) ); + mvd = MVD_SetChannel(1); + if (!mvd) { + Com_Printf("Usage: %s [chan_id] [count]\n", Cmd_Argv(0)); return; } - count = atoi( Cmd_Argv( 2 ) ); - if( count < 1 ) { + count = atoi(Cmd_Argv(2)); + if (count < 1) { count = 1; } - if( !mvd->gtv || !mvd->gtv->demoplayback ) { - Com_Printf( "[%s] Maps can be skipped only on demo channels.\n", mvd->name ); + if (!mvd->gtv || !mvd->gtv->demoplayback) { + Com_Printf("[%s] Maps can be skipped only on demo channels.\n", mvd->name); return; } mvd->gtv->demoskip = count; } -static void MVD_Seek_f( void ) { +static void MVD_Seek_f(void) +{ mvd_t *mvd; gtv_t *gtv; mvd_snap_t *snap; @@ -2080,139 +2149,139 @@ static void MVD_Seek_f( void ) { edict_t *ent; qboolean gamestate; - if( Cmd_Argc() < 2 ) { - Com_Printf( "Usage: %s [+-]<timespec> [chanid]\n", Cmd_Argv( 0 ) ); + if (Cmd_Argc() < 2) { + Com_Printf("Usage: %s [+-]<timespec> [chanid]\n", Cmd_Argv(0)); return; } - mvd = MVD_SetChannel( 2 ); - if( !mvd ) { + mvd = MVD_SetChannel(2); + if (!mvd) { return; } gtv = mvd->gtv; - if( !gtv || !gtv->demoplayback ) { - Com_Printf( "[%s] Seeking is only supported on demo channels.\n", mvd->name ); + if (!gtv || !gtv->demoplayback) { + Com_Printf("[%s] Seeking is only supported on demo channels.\n", mvd->name); return; } - if( mvd->demorecording ) { + if (mvd->demorecording) { // need some sort of nodelta frame support for that :( - Com_Printf( "[%s] Seeking is not yet supported during demo recording, sorry.\n", mvd->name ); + Com_Printf("[%s] Seeking is not yet supported during demo recording, sorry.\n", mvd->name); return; } - to = Cmd_Argv( 1 ); + to = Cmd_Argv(1); - if( *to == '-' || *to == '+' ) { + if (*to == '-' || *to == '+') { // relative to current frame - if( !Com_ParseTimespec( to + 1, &frames ) ) { - Com_Printf( "Invalid relative timespec.\n" ); + if (!Com_ParseTimespec(to + 1, &frames)) { + Com_Printf("Invalid relative timespec.\n"); return; } - if( *to == '-' ) + if (*to == '-') frames = -frames; dest = mvd->framenum + frames; } else { // relative to first frame - if( !Com_ParseTimespec( to, &dest ) ) { - Com_Printf( "Invalid absolute timespec.\n" ); + if (!Com_ParseTimespec(to, &dest)) { + Com_Printf("Invalid absolute timespec.\n"); return; } frames = dest - mvd->framenum; } - if( !frames ) + if (!frames) // already there return; - if( setjmp( mvd_jmpbuf ) ) + if (setjmp(mvd_jmpbuf)) return; // disable effects processing mvd->demoseeking = qtrue; // clear dirty configstrings - memset( mvd->dcs, 0, sizeof( mvd->dcs ) ); + memset(mvd->dcs, 0, sizeof(mvd->dcs)); - Com_DPrintf( "[%d] seeking to %d\n", mvd->framenum, dest ); + Com_DPrintf("[%d] seeking to %d\n", mvd->framenum, dest); // seek to the previous most recent snapshot - if( frames < 0 || mvd->last_snapshot > mvd->framenum ) { - snap = demo_find_snapshot( mvd, dest ); - - if( snap ) { - Com_DPrintf( "found snap at %d\n", snap->framenum ); - ret = FS_Seek( gtv->demoplayback, snap->filepos ); - if( ret < 0 ) { - Com_EPrintf( "[%s] Couldn't seek demo: %s\n", mvd->name, Q_ErrorString( ret ) ); + if (frames < 0 || mvd->last_snapshot > mvd->framenum) { + snap = demo_find_snapshot(mvd, dest); + + if (snap) { + Com_DPrintf("found snap at %d\n", snap->framenum); + ret = FS_Seek(gtv->demoplayback, snap->filepos); + if (ret < 0) { + Com_EPrintf("[%s] Couldn't seek demo: %s\n", mvd->name, Q_ErrorString(ret)); goto done; } // clear delta state - MVD_ClearState( mvd, qfalse ); + MVD_ClearState(mvd, qfalse); // reset configstrings - for( i = 0; i < MAX_CONFIGSTRINGS; i++ ) { + for (i = 0; i < MAX_CONFIGSTRINGS; i++) { from = mvd->baseconfigstrings[i]; to = mvd->configstrings[i]; - if( !strcmp( from, to ) ) + if (!strcmp(from, to)) continue; - Q_SetBit( mvd->dcs, i ); - strcpy( to, from ); + Q_SetBit(mvd->dcs, i); + strcpy(to, from); } // set player names - MVD_SetPlayerNames( mvd ); + MVD_SetPlayerNames(mvd); - SZ_Init( &msg_read, snap->data, snap->msglen ); + SZ_Init(&msg_read, snap->data, snap->msglen); msg_read.cursize = snap->msglen; - MVD_ParseMessage( mvd ); + MVD_ParseMessage(mvd); mvd->framenum = snap->framenum; - } else if( frames < 0 ) { - Com_Printf( "[%s] Couldn't seek backwards without snapshots!\n", mvd->name ); + } else if (frames < 0) { + Com_Printf("[%s] Couldn't seek backwards without snapshots!\n", mvd->name); goto done; } } // skip forward to destination frame - while( mvd->framenum < dest ) { - ret = demo_read_message( gtv->demoplayback ); - if( ret <= 0 ) { - demo_finish( gtv, ret ); + while (mvd->framenum < dest) { + ret = demo_read_message(gtv->demoplayback); + if (ret <= 0) { + demo_finish(gtv, ret); return; } - gamestate = MVD_ParseMessage( mvd ); + gamestate = MVD_ParseMessage(mvd); - demo_emit_snapshot( mvd ); + demo_emit_snapshot(mvd); - if( gamestate ) { + if (gamestate) { // got a gamestate, abort seek - Com_DPrintf( "got gamestate while seeking!\n" ); + Com_DPrintf("got gamestate while seeking!\n"); goto done; } } - Com_DPrintf( "[%d] after skip\n", mvd->framenum ); + Com_DPrintf("[%d] after skip\n", mvd->framenum); // update dirty configstrings - for( i = 0; i < CS_BITMAP_LONGS; i++ ) { - if( ((uint32_t *)mvd->dcs)[i] == 0 ) + for (i = 0; i < CS_BITMAP_LONGS; i++) { + if (((uint32_t *)mvd->dcs)[i] == 0) continue; index = i << 5; - for( j = 0; j < 32; j++, index++ ) { - if( Q_IsBitSet( mvd->dcs, index ) ) - MVD_UpdateConfigstring( mvd, index ); + for (j = 0; j < 32; j++, index++) { + if (Q_IsBitSet(mvd->dcs, index)) + MVD_UpdateConfigstring(mvd, index); } } // ouch - CM_SetPortalStates( &mvd->cm, NULL, 0 ); + CM_SetPortalStates(&mvd->cm, NULL, 0); // init world entity ent = &mvd->edicts[0]; @@ -2220,32 +2289,33 @@ static void MVD_Seek_f( void ) { ent->inuse = qtrue; // relink entities, reset origins and events - for( i = 1; i < mvd->pool.num_edicts; i++ ) { + for (i = 1; i < mvd->pool.num_edicts; i++) { ent = &mvd->edicts[i]; - if( !ent->inuse ) + if (!ent->inuse) continue; - MVD_LinkEdict( mvd, ent ); + MVD_LinkEdict(mvd, ent); - if( !( ent->s.renderfx & RF_BEAM ) ) - VectorCopy( ent->s.origin, ent->s.old_origin ); + if (!(ent->s.renderfx & RF_BEAM)) + VectorCopy(ent->s.origin, ent->s.old_origin); ent->s.event = EV_OTHER_TELEPORT; } - MVD_UpdateClients( mvd ); + MVD_UpdateClients(mvd); // wait one frame to give entity events a chance to be communicated back to // clients gtv->demowait = qtrue; - demo_update( gtv ); + demo_update(gtv); done: mvd->demoseeking = qfalse; } -static void MVD_Control_f( void ) { +static void MVD_Control_f(void) +{ static const cmd_option_t options[] = { { "h", "help", "display this message" }, { "l:number", "loop", "replay <number> of times (0 means forever)" }, @@ -2258,17 +2328,17 @@ static void MVD_Control_f( void ) { int todo = 0; int c; - while( ( c = Cmd_ParseOptions( options ) ) != -1 ) { - switch( c ) { + while ((c = Cmd_ParseOptions(options)) != -1) { + switch (c) { case 'h': - Cmd_PrintUsage( options, "[chanid]" ); - Com_Printf( "Change attributes of existing MVD channel.\n" ); - Cmd_PrintHelp( options ); + Cmd_PrintUsage(options, "[chanid]"); + Com_Printf("Change attributes of existing MVD channel.\n"); + Cmd_PrintHelp(options); return; case 'l': - loop = atoi( cmd_optarg ); - if( loop < 0 ) { - Com_Printf( "Invalid value for %s option.\n", cmd_optopt ); + loop = atoi(cmd_optarg); + if (loop < 0) { + Com_Printf("Invalid value for %s option.\n", cmd_optopt); Cmd_PrintHint(); return; } @@ -2283,24 +2353,24 @@ static void MVD_Control_f( void ) { } } - if( !todo ) { - Com_Printf( "At least one option needed.\n" ); + if (!todo) { + Com_Printf("At least one option needed.\n"); Cmd_PrintHint(); return; } - mvd = MVD_SetChannel( cmd_optind ); - if( !mvd ) { + mvd = MVD_SetChannel(cmd_optind); + if (!mvd) { Cmd_PrintHint(); return; } - if( name ) { - Com_Printf( "[%s] Channel renamed to %s.\n", mvd->name, name ); - Q_strlcpy( mvd->name, name, sizeof( mvd->name ) ); + if (name) { + Com_Printf("[%s] Channel renamed to %s.\n", mvd->name, name); + Q_strlcpy(mvd->name, name, sizeof(mvd->name)); } - if( loop != -1 ) { - //Com_Printf( "[%s] Loop count changed to %d.\n", mvd->name, loop ); + if (loop != -1) { + //Com_Printf("[%s] Loop count changed to %d.\n", mvd->name, loop); //mvd->demoloop = loop; } } @@ -2315,15 +2385,18 @@ static const cmd_option_t o_mvdplay[] = { { NULL } }; -void MVD_File_g( genctx_t *ctx ) { - FS_File_g( "demos", "*.mvd2;*.mvd2.gz", FS_SEARCH_SAVEPATH | FS_SEARCH_BYFILTER, ctx ); +void MVD_File_g(genctx_t *ctx) +{ + FS_File_g("demos", "*.mvd2;*.mvd2.gz", FS_SEARCH_SAVEPATH | FS_SEARCH_BYFILTER, ctx); } -static void MVD_Play_c( genctx_t *ctx, int argnum ) { - Cmd_Option_c( o_mvdplay, MVD_File_g, ctx, argnum ); +static void MVD_Play_c(genctx_t *ctx, int argnum) +{ + Cmd_Option_c(o_mvdplay, MVD_File_g, ctx, argnum); } -static void MVD_Play_f( void ) { +static void MVD_Play_f(void) +{ char *name = NULL; char buffer[MAX_OSPATH]; int loop = -1, chan_id = -1; @@ -2334,19 +2407,19 @@ static void MVD_Play_f( void ) { string_entry_t *entry, *head; int i; - while( ( c = Cmd_ParseOptions( o_mvdplay ) ) != -1 ) { - switch( c ) { + while ((c = Cmd_ParseOptions(o_mvdplay)) != -1) { + switch (c) { case 'h': - Cmd_PrintUsage( o_mvdplay, "[/]<filename> [...]" ); - Com_Printf( "Create new MVD channel and begin demo playback.\n" ); - Cmd_PrintHelp( o_mvdplay ); - Com_Printf( "Final path is formatted as demos/<filename>.mvd2.\n" - "Prepend slash to specify raw path.\n" ); + Cmd_PrintUsage(o_mvdplay, "[/]<filename> [...]"); + Com_Printf("Create new MVD channel and begin demo playback.\n"); + Cmd_PrintHelp(o_mvdplay); + Com_Printf("Final path is formatted as demos/<filename>.mvd2.\n" + "Prepend slash to specify raw path.\n"); return; case 'l': - loop = atoi( cmd_optarg ); - if( loop < 0 ) { - Com_Printf( "Invalid value for %s option.\n", cmd_optopt ); + loop = atoi(cmd_optarg); + if (loop < 0) { + Com_Printf("Invalid value for %s option.\n", cmd_optopt); Cmd_PrintHint(); return; } @@ -2363,106 +2436,107 @@ static void MVD_Play_f( void ) { } argc = Cmd_Argc(); - if( cmd_optind == argc ) { - Com_Printf( "Missing filename argument.\n" ); + if (cmd_optind == argc) { + Com_Printf("Missing filename argument.\n"); Cmd_PrintHint(); return; } - if( chan_id != -1 ) { - mvd_t *mvd = MVD_SetChannel( chan_id ); - if( mvd ) { + if (chan_id != -1) { + mvd_t *mvd = MVD_SetChannel(chan_id); + if (mvd) { gtv = mvd->gtv; } } // build the playlist head = NULL; - for( i = argc - 1; i >= cmd_optind; i-- ) { + for (i = argc - 1; i >= cmd_optind; i--) { // try to open it - f = FS_EasyOpenFile( buffer, sizeof( buffer ), FS_MODE_READ, - "demos/", Cmd_Argv( i ), ".mvd2" ); - if( !f ) { + f = FS_EasyOpenFile(buffer, sizeof(buffer), FS_MODE_READ, + "demos/", Cmd_Argv(i), ".mvd2"); + if (!f) { continue; } - FS_FCloseFile( f ); + FS_FCloseFile(f); - len = strlen( buffer ); - entry = MVD_Malloc( sizeof( *entry ) + len ); - memcpy( entry->string, buffer, len + 1 ); + len = strlen(buffer); + entry = MVD_Malloc(sizeof(*entry) + len); + memcpy(entry->string, buffer, len + 1); entry->next = head; head = entry; } - if( !head ) { + if (!head) { return; } - if( gtv ) { + if (gtv) { // free existing playlist - demo_free_playlist( gtv ); + demo_free_playlist(gtv); } else { // create new connection - gtv = MVD_Mallocz( sizeof( *gtv ) ); + gtv = MVD_Mallocz(sizeof(*gtv)); gtv->id = mvd_chanid++; gtv->state = GTV_READING; gtv->drop = demo_destroy; gtv->destroy = demo_destroy; gtv->demoloop = 1; - Q_snprintf( gtv->name, sizeof( gtv->name ), "dem%d", gtv->id ); + Q_snprintf(gtv->name, sizeof(gtv->name), "dem%d", gtv->id); } // set channel name - if( name ) { - Q_strlcpy( gtv->name, name, sizeof( gtv->name ) ); + if (name) { + Q_strlcpy(gtv->name, name, sizeof(gtv->name)); } // set loop parameter - if( loop != -1 ) { + if (loop != -1) { gtv->demoloop = loop; } // set new playlist gtv->demohead = head; - if( setjmp( mvd_jmpbuf ) ) { + if (setjmp(mvd_jmpbuf)) { return; } - demo_play_next( gtv, head ); + demo_play_next(gtv, head); } -void MVD_Shutdown( void ) { +void MVD_Shutdown(void) +{ gtv_t *gtv, *gtv_next; mvd_t *mvd, *mvd_next; // kill all GTV connections - LIST_FOR_EACH_SAFE( gtv_t, gtv, gtv_next, &mvd_gtv_list, entry ) { - gtv->destroy( gtv ); + LIST_FOR_EACH_SAFE(gtv_t, gtv, gtv_next, &mvd_gtv_list, entry) { + gtv->destroy(gtv); } // kill all MVD channels (including demo GTVs) - LIST_FOR_EACH_SAFE( mvd_t, mvd, mvd_next, &mvd_channel_list, entry ) { - if( mvd->gtv ) { + LIST_FOR_EACH_SAFE(mvd_t, mvd, mvd_next, &mvd_channel_list, entry) { + if (mvd->gtv) { mvd->gtv->mvd = NULL; // don't double destroy - mvd->gtv->destroy( mvd->gtv ); + mvd->gtv->destroy(mvd->gtv); } - MVD_Free( mvd ); + MVD_Free(mvd); } - List_Init( &mvd_gtv_list ); - List_Init( &mvd_channel_list ); + List_Init(&mvd_gtv_list); + List_Init(&mvd_channel_list); - Z_Free( mvd_clients ); + Z_Free(mvd_clients); mvd_clients = NULL; mvd_chanid = 0; mvd_active = qfalse; - Z_LeakTest( TAG_MVD ); + Z_LeakTest(TAG_MVD); } static const cmdreg_t c_mvd[] = { @@ -2487,19 +2561,20 @@ static const cmdreg_t c_mvd[] = { MVD_Register ============== */ -void MVD_Register( void ) { +void MVD_Register(void) +{ #ifdef _DEBUG - mvd_shownet = Cvar_Get( "mvd_shownet", "0", 0 ); + mvd_shownet = Cvar_Get("mvd_shownet", "0", 0); #endif - mvd_timeout = Cvar_Get( "mvd_timeout", "90", 0 ); - mvd_suspend_time = Cvar_Get( "mvd_suspend_time", "5", 0 ); - mvd_wait_delay = Cvar_Get( "mvd_wait_delay", "20", 0 ); - mvd_wait_percent = Cvar_Get( "mvd_wait_percent", "35", 0 ); - mvd_buffer_size = Cvar_Get( "mvd_buffer_size", "3", 0 ); - mvd_username = Cvar_Get( "mvd_username", "unnamed", 0 ); - mvd_password = Cvar_Get( "mvd_password", "", CVAR_PRIVATE ); - mvd_snaps = Cvar_Get( "mvd_snaps", "10", 0 ); - - Cmd_Register( c_mvd ); + mvd_timeout = Cvar_Get("mvd_timeout", "90", 0); + mvd_suspend_time = Cvar_Get("mvd_suspend_time", "5", 0); + mvd_wait_delay = Cvar_Get("mvd_wait_delay", "20", 0); + mvd_wait_percent = Cvar_Get("mvd_wait_percent", "35", 0); + mvd_buffer_size = Cvar_Get("mvd_buffer_size", "3", 0); + mvd_username = Cvar_Get("mvd_username", "unnamed", 0); + mvd_password = Cvar_Get("mvd_password", "", CVAR_PRIVATE); + mvd_snaps = Cvar_Get("mvd_snaps", "10", 0); + + Cmd_Register(c_mvd); } |