1HEADmaster

1 files changed, 2406 insertions, 0 deletions

diff --git a/engine/cl_demo.cpp b/engine/cl_demo.cpp
new file mode 100644
index 0000000..5646166
--- /dev/null
+++ b/engine/cl_demo.cpp
@@ -0,0 +1,2406 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "client_pch.h"
+#include "enginestats.h"
+#include "iprediction.h"
+#include "cl_demo.h"
+#include "cl_demoactionmanager.h"
+#include "cl_pred.h"
+
+#include "baseautocompletefilelist.h"
+#include "demofile/demoformat.h"
+#include "gl_matsysiface.h"
+#include "materialsystem/imaterialsystemhardwareconfig.h"
+#include "tier0/etwprof.h"
+#include "tier0/icommandline.h"
+#include "vengineserver_impl.h"
+#include "console.h"
+#include "dt_common_eng.h"
+#include "net_chan.h"
+#include "gl_model_private.h"
+#include "decal.h"
+#include "icliententitylist.h"
+#include "icliententity.h"
+#include "cl_demouipanel.h"
+#include "materialsystem/materialsystem_config.h"
+#include "tier2/tier2.h"
+#include "vgui_baseui_interface.h"
+#include "con_nprint.h"
+#include "networkstringtableclient.h"
+
+#ifdef SWDS
+#include "server.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static ConVar demo_recordcommands( "demo_recordcommands", "1", FCVAR_CHEAT, "Record commands typed at console into .dem files." );
+static ConVar demo_quitafterplayback( "demo_quitafterplayback", "0", 0, "Quits game after demo playback." );
+static ConVar demo_debug( "demo_debug", "0", 0, "Demo debug info." );
+static ConVar demo_interpolateview( "demo_interpolateview", "1", 0, "Do view interpolation during dem playback." );
+static ConVar demo_pauseatservertick( "demo_pauseatservertick", "0", 0, "Pauses demo playback at server tick" );
+static ConVar timedemo_runcount( "timedemo_runcount", "0", 0, "Runs time demo X number of times." );
+
+// singeltons:
+static char g_pStatsFile[MAX_OSPATH] = { 0 };
+static bool s_bBenchframe = false;
+
+static CDemoRecorder s_ClientDemoRecorder;
+CDemoRecorder *g_pClientDemoRecorder = &s_ClientDemoRecorder;
+IDemoRecorder *demorecorder = g_pClientDemoRecorder;
+
+static CDemoPlayer s_ClientDemoPlayer;
+CDemoPlayer *g_pClientDemoPlayer = &s_ClientDemoPlayer;
+IDemoPlayer *demoplayer = g_pClientDemoPlayer;
+
+extern CNetworkStringTableContainer *networkStringTableContainerClient;
+
+// This is the number of units under which we are allowed to interpolate, otherwise pop.
+// This fixes problems with in-level transitions.
+static ConVar demo_interplimit( "demo_interplimit", "4000", 0, "How much origin velocity before it's considered to have 'teleported' causing interpolation to reset." );
+static ConVar demo_avellimit( "demo_avellimit", "2000", 0, "Angular velocity limit before eyes considered snapped for demo playback." );
+
+#define DEMO_HEADER_FILE	"demoheader.tmp"
+
+// Fast forward convars
+static ConVar demo_fastforwardstartspeed( "demo_fastforwardstartspeed", "2", 0, "Go this fast when starting to hold FF button." );
+static ConVar demo_fastforwardfinalspeed( "demo_fastforwardfinalspeed", "20", 0, "Go this fast when starting to hold FF button." );
+static ConVar demo_fastforwardramptime( "demo_fastforwardramptime", "5", 0, "How many seconds it takes to get to full FF speed." );
+
+float scr_demo_override_fov = 0.0f;
+
+//-----------------------------------------------------------------------------
+// Purpose: Implements IDemo and handles demo file i/o
+// Demos are more or less driven off of network traffic, but there are a few
+//  other kinds of data items that are also included in the demo file:  specifically
+//  commands that the client .dll itself issued to the engine are recorded, though they
+//  probably were not the result of network traffic.
+// At the start of a connection to a map/server, all of the signon, etc. network packets
+//  are buffered.  This allows us to actually decide to start recording the demo at a later
+//  time.  Once we actually issue the recording command, we don't actually start recording 
+//  network traffic, but instead we ask the server for an "uncompressed" packet (otherwise
+//  we wouldn't be able to deal with the incoming packets during playback because we'd be missing the
+//  data to delta from ) and go into a waiting state.  Once an uncompressed packet is received, 
+//  we unset the waiting state and start recording network packets from that point forward.
+// Demo's record the elapsed time based on the current client clock minus the time the demo was started
+// During playback, the elapsed time for playback ( based on the host_time, which is subject to the
+//  host_frametime cvar ) is compared with the elapsed time on the message from the demo file.  
+// If it's not quite time for the message yet, the demo input stream is rewound
+// The demo system sits at the point where the client is checking to see if any network messages
+//  have arrived from the server.  If the message isn't ready for processing, the demo system
+//  just responds that there are no messages waiting and the client continues on
+// Once a true network message with entity data is read from the demo stream, a couple of other
+//  actions occur.  First, the timestamp in the demo file and the view origin/angles corresponding
+//  to the message are cached off.  Then, we search ahead (into the future) to find out the next true network message
+//  we are going to read from the demo file.  We store of it's elapsed time and view origin/angles
+// Every frame that the client is rendering, even if there is no data from the demo system,
+//  the engine asks the demo system to compute an interpolated origin and view angles.  This
+//  is done by taking the current time on the host and figuring out how far that puts us between
+//  the last read origin from the demo file and the time when we'll actually read out and use the next origin
+// We use Quaternions to avoid gimbel lock on interpolating the view angles
+// To make a movie recorded at a fixed frame rate you would simply set the host_framerate to the
+//  desired playback fps ( e.g., 0.02 == 50 fps ), then issue the startmovie command, and then
+//  play the demo.  The demo system will think that the engine is running at 50 fps and will pull
+//  messages accordingly, even though movie recording kills the actually framerate.
+// It will also render frames with render origin/angles interpolated in-between the previous and next origins
+//  even if the recording framerate was not 50 fps or greater.  The interpolation provides a smooth visual playback 
+//  of the demo information to the client without actually adding latency to the view position (because we are
+//  looking into the future for the position, not buffering the past data ).
+//-----------------------------------------------------------------------------
+
+static bool IsControlCommand( unsigned char cmd )
+{
+	return ( (cmd == dem_signon) || (cmd == dem_stop) ||
+		     (cmd == dem_synctick) || (cmd == dem_datatables ) ||
+			 (cmd == dem_stringtables) );
+}
+
+
+// Puts a flashing overlay on the screen during demo recording/playback
+static ConVar cl_showdemooverlay( "cl_showdemooverlay", "0", 0, "How often to flash demo recording/playback overlay (0 - disable overlay, -1 - show always)" );
+
+class DemoOverlay
+{
+public:
+	DemoOverlay();
+	~DemoOverlay();
+
+public:
+	void Tick();
+	void DrawOverlay( float fSetting );
+
+protected:
+	float m_fLastTickTime;
+	float m_fLastTickOverlay;
+	enum Overlay { OVR_NONE = 0, OVR_REC = 1 << 1, OVR_PLAY = 1 << 2 };
+	bool m_bTick;
+	int m_maskDrawnOverlay;
+} g_DemoOverlay;
+
+DemoOverlay::DemoOverlay() :
+	m_fLastTickTime( 0.f ), m_fLastTickOverlay( 0.f ), m_bTick( false ), m_maskDrawnOverlay( OVR_NONE )
+{
+}
+
+DemoOverlay::~DemoOverlay()
+{
+}
+
+void DemoOverlay::Tick()
+{
+	if ( !m_bTick )
+	{
+		m_bTick = true;
+
+		float const fRealTime = Sys_FloatTime();
+		if ( m_fLastTickTime != fRealTime )
+		{
+			m_fLastTickTime = fRealTime;
+
+			float const fDelta = m_fLastTickTime - m_fLastTickOverlay;
+			float const fSettingDelta = cl_showdemooverlay.GetFloat();
+
+			if ( fSettingDelta <= 0.f ||
+				fDelta >= fSettingDelta )
+			{
+				m_fLastTickOverlay = m_fLastTickTime;
+				DrawOverlay( fSettingDelta );
+			}
+		}
+
+		m_bTick = false;
+	}
+}
+
+void DemoOverlay::DrawOverlay( float fSetting )
+{
+	int maskDrawnOverlay = OVR_NONE;
+
+	if ( fSetting < 0.f )
+	{
+		// Keep drawing
+		maskDrawnOverlay =
+			( demorecorder->IsRecording() ? OVR_REC : 0 ) |
+			( demoplayer->IsPlayingBack() ? OVR_PLAY : 0 );
+	}
+	else if ( fSetting == 0.f )
+	{
+		// None
+		maskDrawnOverlay = OVR_NONE;
+	}
+	else
+	{
+		// Flash
+		maskDrawnOverlay = ( !m_maskDrawnOverlay ) ? (
+			( demorecorder->IsRecording() ? OVR_REC : 0 ) |
+			( demoplayer->IsPlayingBack() ? OVR_PLAY : 0 )
+			) : OVR_NONE;
+	}
+
+	int const idx = 1;
+
+	if ( OVR_NONE == maskDrawnOverlay &&
+		 OVR_NONE != m_maskDrawnOverlay )
+	{
+		con_nprint_s xprn;
+		memset( &xprn, 0, sizeof( xprn ) );
+		xprn.index = idx;
+		xprn.time_to_live = -1;
+		Con_NXPrintf( &xprn, "" );
+	}
+	
+	if ( OVR_PLAY & maskDrawnOverlay )
+	{
+		con_nprint_s xprn;
+		memset( &xprn, 0, sizeof( xprn ) );
+		xprn.index = idx;
+		xprn.color[0] = 0.f;
+		xprn.color[1] = 1.f;
+		xprn.color[2] = 0.f;
+		xprn.fixed_width_font = true;
+		xprn.time_to_live = ( fSetting > 0.f ) ? fSetting : 1.f;
+		Con_NXPrintf( &xprn, "  PLAY   " );
+	}
+	
+	if ( OVR_REC & maskDrawnOverlay )
+	{
+		con_nprint_s xprn;
+		memset( &xprn, 0, sizeof( xprn ) );
+		xprn.index = idx;
+		xprn.color[0] = 1.f;
+		xprn.color[1] = 0.f;
+		xprn.color[2] = 0.f;
+		xprn.fixed_width_font = true;
+		xprn.time_to_live = ( fSetting > 0.f ) ? fSetting : 1.f;
+		Con_NXPrintf( &xprn, "   REC   " );
+	}
+
+	m_maskDrawnOverlay = maskDrawnOverlay;
+}
+			
+
+//-----------------------------------------------------------------------------
+// Purpose: Mark whether we are waiting for the first uncompressed update packet
+// Input  : waiting - 
+//-----------------------------------------------------------------------------
+void CDemoRecorder::SetSignonState(int state)
+{
+	if ( demoplayer->IsPlayingBack() )
+		return;
+
+	if ( state == SIGNONSTATE_NEW )
+	{
+		if ( m_DemoFile.IsOpen() )
+		{
+			// we are already recording a demo file
+			CloseDemoFile();
+
+			// prepare for recording next demo
+			m_nDemoNumber++; 
+		}
+
+		StartupDemoHeader();
+	}
+	else if ( state == SIGNONSTATE_SPAWN )
+	{
+		// close demo file header when this packet is finished
+		m_bCloseDemoFile = true;
+	}
+	else if ( state == SIGNONSTATE_FULL )
+	{
+		if ( m_bRecording )
+		{
+			StartupDemoFile();
+		}
+	}
+}
+
+int CDemoRecorder::GetRecordingTick( void )
+{
+	if ( cl.m_nMaxClients > 1 )
+	{
+		return TIME_TO_TICKS( net_time ) - m_nStartTick;
+	}
+	else
+	{
+		return cl.GetClientTickCount() - m_nStartTick;
+	}
+}
+
+void CDemoRecorder::ResyncDemoClock()
+{
+	if ( cl.m_nMaxClients > 1 )
+	{
+		m_nStartTick = TIME_TO_TICKS( net_time );
+	}
+	else
+	{
+		m_nStartTick = cl.GetClientTickCount();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : info - 
+//-----------------------------------------------------------------------------
+void CDemoRecorder::GetClientCmdInfo( democmdinfo_t& info )
+{
+	info.flags		= FDEMO_NORMAL;
+
+	if( m_bResetInterpolation )
+	{
+		info.flags |= FDEMO_NOINTERP;
+		m_bResetInterpolation = false;
+	}
+
+	g_pClientSidePrediction->GetViewOrigin( info.viewOrigin );
+#ifndef SWDS
+	info.viewAngles = cl.viewangles;
+#endif
+	g_pClientSidePrediction->GetLocalViewAngles( info.localViewAngles );
+
+	// Nothing by default
+	info.viewOrigin2.Init();
+	info.viewAngles2.Init();
+	info.localViewAngles2.Init();
+}
+
+void CDemoRecorder::WriteBSPDecals()
+{
+	decallist_t	*decalList = (decallist_t*)malloc( sizeof(decallist_t) * Draw_DecalMax() );
+	
+	int decalcount = DecalListCreate( decalList );
+
+	char		data[NET_MAX_PAYLOAD];
+	bf_write	msg;
+
+	msg.StartWriting( data, NET_MAX_PAYLOAD );
+	msg.SetDebugName( "DemoFileWriteBSPDecals" );
+
+	for ( int i = 0; i < decalcount; i++ )
+	{
+		decallist_t *entry = &decalList[ i ];
+
+		SVC_BSPDecal decal;
+
+		bool found = false;
+
+		IClientEntity *clientEntity = entitylist->GetClientEntity( entry->entityIndex );
+
+		if ( !clientEntity )
+			continue;
+
+		
+		const model_t * pModel = clientEntity->GetModel();
+
+		decal.m_Pos = entry->position;
+		decal.m_nEntityIndex = entry->entityIndex;
+		decal.m_nDecalTextureIndex = Draw_DecalIndexFromName( entry->name, &found );
+		decal.m_nModelIndex = 0;
+
+		if ( pModel )
+		{
+			decal.m_nModelIndex = cl.LookupModelIndex( modelloader->GetName( pModel ) );
+		}
+
+		decal.WriteToBuffer( msg );
+	}
+
+	WriteMessages( msg );
+	
+	free( decalList );
+}
+
+void CDemoRecorder::RecordServerClasses( ServerClass *pClasses )
+{
+	MEM_ALLOC_CREDIT();
+
+	char *pBigBuffer;
+	CUtlBuffer bigBuff;
+
+	int buffSize = 256*1024;
+	if ( !IsX360() )
+	{
+		pBigBuffer = (char*)stackalloc( buffSize );
+	}
+	else
+	{
+		// keep temp large allocations off of stack
+		bigBuff.EnsureCapacity( buffSize );
+		pBigBuffer = (char*)bigBuff.Base();
+	}
+
+	bf_write buf( pBigBuffer, buffSize );
+
+	// Send SendTable info.
+	DataTable_WriteSendTablesBuffer( pClasses, &buf );
+
+	// Send class descriptions.
+	DataTable_WriteClassInfosBuffer( pClasses, &buf );
+
+	// Now write the buffer into the demo file
+	m_DemoFile.WriteNetworkDataTables( &buf, GetRecordingTick() );
+}
+
+void CDemoRecorder::RecordStringTables()
+{
+	MEM_ALLOC_CREDIT();
+
+	// !KLUDGE! It would be nice if the bit buffer could write into a stream
+	// with the power to grow itself.  But it can't.  Hence this really bad
+	// kludge
+	void *data = NULL;
+	int dataLen = 512 * 1024;
+	while ( dataLen <= DEMO_FILE_MAX_STRINGTABLE_SIZE )
+	{
+		data = realloc( data, dataLen );
+		bf_write buf( data, dataLen );
+		buf.SetDebugName("CDemoRecorder::RecordStringTables");
+		buf.SetAssertOnOverflow( false ); // Doesn't turn off all the spew / asserts, but turns off one
+		networkStringTableContainerClient->WriteStringTables( buf );
+
+		// Did we fit?
+		if ( !buf.IsOverflowed() )
+		{
+			// Now write the buffer into the demo file
+			m_DemoFile.WriteStringTables( &buf, GetRecordingTick() );
+			break;
+		}
+
+		// Didn't fit.  Try doubling the size of the buffer
+		dataLen *= 2;
+	}
+
+	if ( dataLen > DEMO_FILE_MAX_STRINGTABLE_SIZE )
+	{
+		Warning( "Failed to RecordStringTables. Trying to record string table that's bigger than max string table size\n" );
+	}
+
+	free(data);
+}
+
+void CDemoRecorder::RecordUserInput( int cmdnumber )
+{
+	char buffer[256];
+	bf_write msg( "CDemo::WriteUserCmd", buffer, sizeof(buffer) );
+
+	g_ClientDLL->EncodeUserCmdToBuffer( msg, cmdnumber );
+
+	m_DemoFile.WriteUserCmd( cmdnumber, buffer, msg.GetNumBytesWritten(), GetRecordingTick() );
+}
+
+void CDemoRecorder::ResetDemoInterpolation( void )
+{
+	m_bResetInterpolation = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: saves all cvars falgged with FVAR_DEMO to demo file
+//-----------------------------------------------------------------------------
+void CDemoRecorder::WriteDemoCvars()
+{
+	const ConCommandBase *var;
+	
+	for ( var= g_pCVar->GetCommands() ; var ; var=var->GetNext() )
+	{
+		if ( var->IsCommand() )
+			continue;
+
+		const ConVar *pCvar = ( const ConVar * )var;
+
+		if ( !pCvar->IsFlagSet( FCVAR_DEMO ) )
+			continue;
+
+		char cvarcmd[MAX_OSPATH];
+
+		Q_snprintf( cvarcmd, sizeof(cvarcmd),"%s \"%s\"",
+			pCvar->GetName(), Host_CleanupConVarStringValue( pCvar->GetString() ) );
+
+		m_DemoFile.WriteConsoleCommand( cvarcmd, GetRecordingTick() );
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *cmdname - 
+//-----------------------------------------------------------------------------
+void CDemoRecorder::RecordCommand( const char *cmdstring )
+{
+	if ( !IsRecording() )
+		return;
+
+	if ( !cmdstring || !cmdstring[0] )
+		return;
+
+	if ( !demo_recordcommands.GetInt() )
+		return;
+
+	m_DemoFile.WriteConsoleCommand( cmdstring, GetRecordingTick() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CDemoRecorder::StartupDemoHeader( void )
+{
+	CloseDemoFile();	// make sure it's closed
+
+	// Note: this is replacing tmpfile()
+	if ( !m_DemoFile.Open( DEMO_HEADER_FILE, false ) )
+	{
+		ConDMsg ("ERROR: couldn't open temporary header file.\n");
+		return;
+	}
+
+	m_bIsDemoHeader = true;
+
+	Assert( m_MessageData.GetBasePointer() == NULL );
+
+	// setup writing data buffer
+	m_MessageData.StartWriting( new unsigned char[NET_MAX_PAYLOAD], NET_MAX_PAYLOAD );
+	m_MessageData.SetDebugName( "DemoHeaderWriteBuffer" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CDemoRecorder::StartupDemoFile( void )
+{
+	if ( !m_bRecording )
+		return;
+
+	// Already recording!!!
+	if ( m_DemoFile.IsOpen() )
+		return;
+
+	char demoFileName[MAX_OSPATH];
+
+	if ( m_nDemoNumber <= 1 )
+	{
+		V_sprintf_safe( demoFileName, "%s.dem", m_szDemoBaseName );
+	}
+	else
+	{
+		V_sprintf_safe( demoFileName, "%s_%i.dem", m_szDemoBaseName, m_nDemoNumber );
+	}
+
+	// strip any trailing whitespace
+	Q_StripPrecedingAndTrailingWhitespace( demoFileName );
+
+	// make sure the .dem extension is still present
+	char ext[10];
+	Q_ExtractFileExtension( demoFileName, ext, sizeof( ext ) );
+	if ( Q_strcasecmp( ext, "dem" ) )
+	{
+		ConMsg( "StartupDemoFile: invalid filename.\n" );
+		return;
+	}
+
+	if ( !m_DemoFile.Open( demoFileName, false ) )
+		return;
+
+	// open demo header file containing sigondata
+	FileHandle_t hDemoHeader = g_pFileSystem->Open( DEMO_HEADER_FILE, "rb"	);
+	if ( hDemoHeader == FILESYSTEM_INVALID_HANDLE )
+	{
+		ConMsg ("StartupDemoFile: couldn't open demo file header.\n");
+		return;
+	}
+
+	Assert( m_MessageData.GetBasePointer() == NULL );
+
+	// setup writing data buffer
+	m_MessageData.StartWriting( new unsigned char[NET_MAX_PAYLOAD], NET_MAX_PAYLOAD );
+	m_MessageData.SetDebugName( "DemoFileWriteBuffer" );
+
+	// fill demo header info
+	demoheader_t *dh = &m_DemoFile.m_DemoHeader;
+	Q_memset(dh, 0, sizeof(demoheader_t));
+
+	dh->demoprotocol = DEMO_PROTOCOL;
+	dh->networkprotocol = PROTOCOL_VERSION;
+	Q_strncpy(dh->demofilestamp, DEMO_HEADER_ID, sizeof(dh->demofilestamp) );
+
+	Q_FileBase( modelloader->GetName( host_state.worldmodel ), dh->mapname, sizeof( dh->mapname ) );
+
+	char szGameDir[MAX_OSPATH];
+	Q_strncpy(szGameDir, com_gamedir, sizeof( szGameDir ) );
+	Q_FileBase ( szGameDir, dh->gamedirectory, sizeof( dh->gamedirectory ) );
+
+	Q_strncpy( dh->servername, cl.m_szRetryAddress, sizeof( dh->servername ) );
+	Q_strncpy( dh->clientname, cl_name.GetString(), sizeof( dh->clientname ) );
+
+	
+	// get size	signon data size
+	dh->signonlength = g_pFileSystem->Size(hDemoHeader);
+	
+	// write demo file header info
+	m_DemoFile.WriteDemoHeader();
+	
+	// copy signon data from header file to demo file
+	m_DemoFile.WriteFileBytes( hDemoHeader, dh->signonlength );
+
+	// close but keep header file, we might need it for a second record
+	g_pFileSystem->Close( hDemoHeader );
+	
+	m_nFrameCount = 0;
+	m_bIsDemoHeader = false;
+		
+	ResyncDemoClock(); // reset demo clock
+		
+	// tell client to sync demo clock too 
+	m_DemoFile.WriteCmdHeader( dem_synctick, 0 );
+	
+	RecordStringTables();
+
+	// Demo playback should read this as an incoming message.
+	WriteDemoCvars(); // save all cvars marked with FCVAR_DEMO
+
+	WriteBSPDecals();
+
+	g_ClientDLL->HudReset();
+
+	//  tell server that we started recording a demo
+	cl.SendStringCmd( "demorestart" );
+
+	ConMsg ("Recording to %s...\n", demoFileName);
+
+	g_ClientDLL->OnDemoRecordStart( m_szDemoBaseName );
+}
+
+CDemoRecorder::CDemoRecorder()
+{
+}
+
+CDemoRecorder::~CDemoRecorder()
+{
+	CloseDemoFile();	
+}
+
+CDemoFile *CDemoRecorder::GetDemoFile()
+{
+	return &m_DemoFile;
+}
+
+void CDemoRecorder::ResumeRecording()
+{
+
+}
+
+void CDemoRecorder::PauseRecording()
+{
+
+}
+
+
+void CDemoRecorder::CloseDemoFile()
+{
+	if ( m_DemoFile.IsOpen())
+	{
+		if ( !m_bIsDemoHeader )
+		{
+			// Demo playback should read this as an incoming message.
+			m_DemoFile.WriteCmdHeader( dem_stop, GetRecordingTick() );
+
+			// update demo header infos
+			m_DemoFile.m_DemoHeader.playback_ticks	= GetRecordingTick();
+			m_DemoFile.m_DemoHeader.playback_time	= host_state.interval_per_tick * GetRecordingTick();
+			m_DemoFile.m_DemoHeader.playback_frames = m_nFrameCount;
+
+			// go back to header and write demoHeader with correct time and #frame again
+			m_DemoFile.WriteDemoHeader();
+
+			ConMsg ("Completed demo, recording time %.1f, game frames %i.\n", 
+				m_DemoFile.m_DemoHeader.playback_time, m_DemoFile.m_DemoHeader.playback_frames );
+		}
+
+		if ( demo_debug.GetInt() )
+		{
+			ConMsg ("Closed demo file, %i bytes.\n", m_DemoFile.GetSize() );
+		}
+
+		m_DemoFile.Close();
+
+		g_ClientDLL->OnDemoRecordStop();
+	}
+
+	m_bCloseDemoFile = false;
+	m_bIsDemoHeader = false;
+
+	// clear writing data buffer
+	if ( m_MessageData.GetBasePointer() )
+	{
+		delete [] m_MessageData.GetBasePointer();
+		m_MessageData.StartWriting( NULL, 0 );
+	}
+}
+
+void CDemoRecorder::RecordMessages(bf_read &data, int bits)
+{
+	if ( m_MessageData.GetBasePointer() && (bits>0) )
+	{
+		m_MessageData.WriteBitsFromBuffer( &data, bits );
+
+		Assert( !m_MessageData.IsOverflowed() );
+	}
+}
+
+void CDemoRecorder::RecordPacket()
+{
+	WriteMessages( m_MessageData );
+
+	m_MessageData.Reset(); // clear message buffer
+	
+	if ( m_bCloseDemoFile )
+	{
+		CloseDemoFile();
+	}
+}
+
+void CDemoRecorder::WriteMessages( bf_write &message )
+{
+	int len = message.GetNumBytesWritten();
+
+	if (len <= 0)
+		return;
+
+	// fill last bits in last byte with NOP if necessary
+	int nRemainingBits = message.GetNumBitsWritten() % 8;
+	if ( nRemainingBits > 0 &&  nRemainingBits <= (8-NETMSG_TYPE_BITS) )
+	{
+		message.WriteUBitLong( net_NOP, NETMSG_TYPE_BITS );
+	}
+
+	Assert( len < NET_MAX_MESSAGE );
+
+	// if signondata read as fast as possible, no rewind
+	// and wait for packet time
+	unsigned char cmd = m_bIsDemoHeader ? dem_signon : dem_packet;
+
+	if ( cmd == dem_packet )
+	{
+		m_nFrameCount++;
+	}
+
+	// write command & time
+	m_DemoFile.WriteCmdHeader( cmd, GetRecordingTick() ); 
+	
+	democmdinfo_t info;
+	// Snag current info
+	GetClientCmdInfo( info );
+		
+	// Store it
+	m_DemoFile.WriteCmdInfo( info );
+		
+	// write network channel sequencing infos
+	int nOutSequenceNr, nInSequenceNr, nOutSequenceNrAck;
+	cl.m_NetChannel->GetSequenceData( nOutSequenceNr, nInSequenceNr, nOutSequenceNrAck );
+	m_DemoFile.WriteSequenceInfo( nInSequenceNr, nOutSequenceNrAck );
+	
+	// Output the messge buffer.
+	m_DemoFile.WriteRawData( (char*) message.GetBasePointer(), len );
+
+	if ( demo_debug.GetInt() >= 1 )
+	{
+		Msg( "Writing demo message %i bytes at file pos %i\n", len, m_DemoFile.GetCurPos( false ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: stop recording a demo
+//-----------------------------------------------------------------------------
+void CDemoRecorder::StopRecording( void )
+{
+	if ( !IsRecording() )
+	{
+		return;
+	}
+
+	if ( m_MessageData.GetBasePointer() )
+	{
+		delete[] m_MessageData.GetBasePointer();
+		m_MessageData.StartWriting( NULL, 0);
+	}
+
+	CloseDemoFile();
+	
+	m_bRecording = false;
+	m_nDemoNumber = 0;
+
+	g_DemoOverlay.Tick();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//			track - 
+//-----------------------------------------------------------------------------
+void CDemoRecorder::StartRecording( const char *name, bool bContinuously )
+{
+	Q_strncpy( m_szDemoBaseName, name, sizeof(m_szDemoBaseName));
+	
+	m_bRecording		 = true;
+	m_nDemoNumber		 = 1;
+	m_bResetInterpolation = false;
+
+
+	g_DemoOverlay.Tick();
+
+	// request a full game update from server 
+	cl.ForceFullUpdate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CDemoRecorder::IsRecording( void )
+{
+	g_DemoOverlay.Tick();
+
+	return m_bRecording;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when a demo file runs out, or the user starts a game
+// Output : void CDemo::StopPlayback
+//-----------------------------------------------------------------------------
+void CDemoPlayer::StopPlayback( void )
+{
+	if ( !IsPlayingBack() )
+		return;
+
+	demoaction->StopPlaying();
+
+	m_DemoFile.Close();
+	m_bPlayingBack = false;
+	m_bLoading = false;
+	m_bPlaybackPaused = false;
+	m_flAutoResumeTime = 0.0f;
+	m_nEndTick = 0;
+
+	if ( m_bTimeDemo )
+	{
+		g_EngineStats.EndRun();
+
+		if ( !s_bBenchframe )
+		{
+			WriteTimeDemoResults();
+		}
+		else
+		{
+			mat_norendering.SetValue( 0 );
+		}
+
+		m_bTimeDemo = false;
+	}
+	else
+	{
+		int framecount = host_framecount - m_nTimeDemoStartFrame;
+		float demotime = Sys_FloatTime() - m_flTimeDemoStartTime;
+
+		if ( demotime > 0.0f )
+		{
+			DevMsg( "Demo playback finished ( %.1f seconds, %i render frames, %.2f fps).\n", demotime, framecount, framecount/demotime);
+		}
+
+	}
+	
+	m_flPlaybackRateModifier = 1.0f;
+
+	delete[] m_DemoPacket.data;
+	m_DemoPacket.data = NULL;
+
+	scr_demo_override_fov = 0.0f;
+
+	if ( timedemo_runcount.GetInt() > 1 )
+	{
+		timedemo_runcount.SetValue( timedemo_runcount.GetInt() - 1 );
+
+		Cbuf_AddText( va( "timedemo %s", m_DemoFile.m_szFileName ) );
+	}
+	else if ( demo_quitafterplayback.GetBool() )
+	{
+		Cbuf_AddText( "quit\n" );
+	}
+
+	g_ClientDLL->OnDemoPlaybackStop();
+}
+
+CDemoFile *CDemoPlayer::GetDemoFile( void )
+{
+	return &m_DemoFile;
+}
+
+#define SKIP_TO_TICK_FLAG uint32( uint32( 0x88 ) << 24 )
+
+bool CDemoPlayer::IsSkipping( void )
+{
+	return m_bPlayingBack && ( m_nSkipToTick != -1 );
+}
+
+bool CDemoPlayer::IsLoading( void )
+{
+	return m_bLoading;
+}
+
+int CDemoPlayer::GetTotalTicks(void)
+{
+	return m_DemoFile.m_DemoHeader.playback_ticks;	
+}
+
+void CDemoPlayer::SkipToTick( int tick, bool bRelative, bool bPause )
+{
+	if ( bRelative )
+	{
+		tick = GetPlaybackTick() + tick;
+	}
+
+	if ( tick < 0 )
+		return;
+
+	if ( tick < GetPlaybackTick() )
+	{
+		// we have to reload the whole demo file
+		// we need to create a temp copy of the filename
+		char fileName[MAX_OSPATH];
+		Q_strncpy( fileName, m_DemoFile.m_szFileName, sizeof(fileName) );
+
+		// reload current demo file
+		ETWMarkPrintf( "DemoPlayer: Reloading demo file '%s'", fileName );
+		StartPlayback( fileName, m_bTimeDemo );
+
+		// Make sure the proper skipping occurs after reload
+		if ( tick > 0 )
+			tick |= SKIP_TO_TICK_FLAG;
+	}
+
+	m_nSkipToTick = tick;
+	ETWMark1I( "DemoPlayer: SkipToTick", tick );
+
+	if ( bPause )
+		PausePlayback( -1 );
+}
+
+void CDemoPlayer::SetEndTick( int tick )
+{
+	if ( tick < 0 )
+		return;
+
+	m_nEndTick = tick;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Read in next demo message and send to local client over network channel, if it's time.
+// Output : bool 
+//-----------------------------------------------------------------------------
+bool CDemoPlayer::ParseAheadForInterval( int curtick, int intervalticks )
+{
+	int			tick = 0;
+	int			dummy;
+	byte		cmd = dem_stop;
+
+	democmdinfo_t	nextinfo;
+
+	long		starting_position = m_DemoFile.GetCurPos( true );
+
+	// remove all entrys older than 32 ticks
+	while ( m_DestCmdInfo.Count() > 0 )
+	{
+		DemoCommandQueue& entry = m_DestCmdInfo[ 0 ];
+
+		if ( entry.tick >= (curtick - 32)  )
+			break;
+
+		if ( entry.filepos >= starting_position )
+			break;
+
+		 m_DestCmdInfo.Remove( 0 );
+	}
+
+	if ( m_bTimeDemo ) 
+		return false;
+
+	while ( true )
+	{
+		// skip forward to the next dem_packet or dem_signon
+		bool swallowmessages = true;
+		do
+		{
+			m_DemoFile.ReadCmdHeader( cmd, tick );
+
+			// COMMAND HANDLERS
+			switch ( cmd )
+			{
+			case dem_synctick:
+			case dem_stop:
+				{
+					m_DemoFile.SeekTo( starting_position, true );
+					return false;
+				}
+				break;
+			case dem_consolecmd:
+				{
+					m_DemoFile.ReadConsoleCommand();
+				}
+				break;
+			case dem_datatables:
+				{
+					m_DemoFile.ReadNetworkDataTables( NULL );
+				}
+				break;
+			case dem_usercmd:
+				{
+					m_DemoFile.ReadUserCmd( NULL, dummy );
+				}
+				break;
+			case dem_stringtables:
+				{
+					m_DemoFile.ReadStringTables( NULL );
+				}
+				break;
+			default:
+				{
+					swallowmessages = false;
+				}
+				break;
+			}
+		}
+		while ( swallowmessages );
+
+		int curpos = m_DemoFile.GetCurPos( true );
+
+		// we read now a dem_packet
+		m_DemoFile.ReadCmdInfo( nextinfo );
+		m_DemoFile.ReadSequenceInfo( dummy, dummy ); 
+		m_DemoFile.ReadRawData( NULL, 0 );
+
+		DemoCommandQueue entry;
+		entry.info = nextinfo;
+		entry.tick = tick;
+		entry.filepos = curpos;
+
+		int i = 0;
+		int c =  m_DestCmdInfo.Count();
+		for ( ; i < c; ++i )
+		{
+			if (  m_DestCmdInfo[ i ].filepos == entry.filepos )
+				break; // cmdinfo is already in list
+		}
+
+		if ( i >= c )
+		{
+			// add cmdinfo to list
+			if ( c > 0 )
+			{
+				if (  m_DestCmdInfo[ c - 1 ].tick > tick )
+				{
+					 m_DestCmdInfo.RemoveAll();
+				}
+			}
+
+			m_DestCmdInfo.AddToTail( entry );
+		}
+
+		if ( ( tick - curtick ) > intervalticks )
+			break;
+	}
+
+	m_DemoFile.SeekTo( starting_position, true );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Read in next demo message and send to local client over network channel, if it's time.
+// Output : netpacket_t* -- NULL if there is no packet available at this time.
+//-----------------------------------------------------------------------------
+netpacket_t *CDemoPlayer::ReadPacket( void )
+{
+	int			tick = 0;
+	byte		cmd = dem_signon;
+	long		curpos = 0;
+
+	if ( ! m_DemoFile.IsOpen() )
+	{
+		m_bPlayingBack = false;
+		Host_EndGame( true, "Tried to read a demo message with no demo file\n" );
+		return NULL;
+	}
+
+	// If game is still shutting down, then don't read any demo messages from file quite yet
+	if ( HostState_IsGameShuttingDown() )
+	{
+		return NULL;
+	}
+
+	Assert( IsPlayingBack() );
+
+	if ( IsSkipping() )
+	{
+		// Every nMaxConsecutiveSkipPackets frames return NULL so that we don't build up an
+		// endless supply of unprocessed packets. This avoids causing overflows and excessive
+		// "highwater marks" in various Dota subsystems.
+		++m_nSkipPacketsPlayed;
+		if ( m_nSkipPacketsPlayed >= nMaxConsecutiveSkipPackets )
+		{
+			m_nSkipPacketsPlayed = 0;
+			return NULL;
+		}
+	}
+	else
+	{
+		m_nSkipPacketsPlayed = 0;
+	}
+
+	// External editor has paused playback
+	if ( CheckPausedPlayback() )
+		return NULL;
+
+	bool bStopReading = false;
+	
+	while ( !bStopReading )
+	{
+		curpos = m_DemoFile.GetCurPos( true );
+
+		m_DemoFile.ReadCmdHeader( cmd, tick );
+
+		// always read control commands 
+		if ( !IsControlCommand( cmd ) )
+		{
+			int playbacktick = GetPlaybackTick();
+
+#if defined( RAD_TELEMETRY_ENABLED )
+			g_Telemetry.playbacktick = playbacktick;
+#endif
+
+			// If the end tick is set, check to see if we should bail
+			if ( m_nEndTick > 0 && playbacktick >= m_nEndTick )
+			{
+				m_nEndTick = 0;
+				return NULL;
+			}
+
+			if ( !m_bTimeDemo )
+			{
+				// Time demo ignores clocks and tries to synchronize frames to what was recorded
+				//  I.e., while frame is the same, read messages, otherwise, skip out.
+				// If we're still signing on, then just parse messages until fully connected no matter what
+				if ( cl.IsActive() &&
+					(tick > playbacktick) && !IsSkipping() )
+				{
+					// is not time yet
+					bStopReading = true;
+				}
+			}
+			else
+			{
+				if ( m_nTimeDemoCurrentFrame == host_framecount )
+				{
+					// If we are playing back a timedemo, and we've already passed on a 
+					//  frame update for this host_frame tag, then we'll just skip this mess
+					bStopReading = true;
+				}
+			}
+
+			if ( bStopReading )
+			{
+				demoaction->Update( false, playbacktick, TICKS_TO_TIME( playbacktick )  );
+				m_DemoFile.SeekTo( curpos, true ); // go back to start of current demo command
+				return NULL;   // Not time yet, dont return packet data.
+			}
+		}
+
+		// COMMAND HANDLERS
+		switch ( cmd )
+		{
+		case dem_synctick:
+			{
+				if ( demo_debug.GetBool() )
+				{
+					Msg( "%d dem_synctick\n", tick );
+				}
+
+				ResyncDemoClock();
+
+				// Once demo clock got resync-ed we can go ahead and
+				// perform skipping logic normally
+				if ( ( m_nSkipToTick != -1 ) &&
+					 ( ( m_nSkipToTick & SKIP_TO_TICK_FLAG ) == SKIP_TO_TICK_FLAG ) )
+				{
+					m_nSkipToTick &= ~SKIP_TO_TICK_FLAG;
+				}
+			}
+			break;
+		case dem_stop:
+			{
+				if ( demo_debug.GetBool() )
+				{
+					Msg( "%d dem_stop\n", tick );
+				}
+
+				OnStopCommand();
+
+				return NULL;
+			}
+			break;
+		case dem_consolecmd:
+			{
+				const char * command = m_DemoFile.ReadConsoleCommand();
+
+				if ( demo_debug.GetBool() )
+				{
+					Msg( "%d dem_consolecmd [%s]\n", tick, command );
+				}
+
+				Cbuf_AddText( command );
+				Cbuf_Execute();
+			}
+			break;
+		case dem_datatables:
+			{
+				if ( demo_debug.GetBool() )
+				{
+					Msg( "%d dem_datatables\n", tick );
+				}
+
+				void *data = malloc( 256*1024 ); // X360TBD: How much memory is really needed here?
+				bf_read buf( "dem_datatables", data, 256*1024 );
+				m_DemoFile.ReadNetworkDataTables( &buf );
+				buf.Seek( 0 );								// re-read data
+
+				// support for older engine demos
+				if ( !DataTable_LoadDataTablesFromBuffer( &buf, m_DemoFile.m_DemoHeader.demoprotocol ) )
+				{
+					Host_Error( "Error parsing network data tables during demo playback." );
+				}
+				free( data );
+			}
+			break;
+		case dem_stringtables:
+			{
+				void *data = NULL;
+				int dataLen = 512 * 1024;
+				while ( dataLen <= DEMO_FILE_MAX_STRINGTABLE_SIZE )
+				{
+					data = realloc( data, dataLen );
+					bf_read buf( "dem_stringtables", data, dataLen );
+					// did we successfully read
+					if ( m_DemoFile.ReadStringTables( &buf ) > 0 )
+					{
+						buf.Seek( 0 );
+						if ( !networkStringTableContainerClient->ReadStringTables( buf ) )
+						{
+							Host_Error( "Error parsing string tables during demo playback." );
+						}
+						break;
+					}
+
+					// Didn't fit.  Try doubling the size of the buffer
+					dataLen *= 2;
+				}
+
+				if ( dataLen > DEMO_FILE_MAX_STRINGTABLE_SIZE )
+				{
+					Warning( "ReadPacket failed to read string tables. Trying to read string tables that's bigger than max string table size\n" );
+				}
+
+				free( data );
+			}
+			break;
+		case dem_usercmd:
+			{
+
+				if ( demo_debug.GetBool() )
+				{
+					Msg( "%d dem_usercmd\n", tick );
+				}
+
+				char buffer[256];
+				int  length = sizeof(buffer);
+				int outgoing_sequence = m_DemoFile.ReadUserCmd( buffer, length );
+
+				// put it into a bitbuffer 
+				bf_read msg( "CDemo::ReadUserCmd", buffer, length );
+
+				g_ClientDLL->DecodeUserCmdFromBuffer( msg, outgoing_sequence );
+
+				// Note, we need to have the current outgoing sequence correct so we can do prediction
+				//  correctly during playback
+				cl.lastoutgoingcommand = outgoing_sequence;
+				
+			}
+			break;
+		default:
+			{
+				bStopReading = true;
+
+				if ( IsSkipping() )
+				{
+					// adjust playback host_tickcount when skipping
+					m_nStartTick = host_tickcount - tick;
+				}
+			}
+			break;
+		}
+	}
+
+	if ( cmd == dem_packet )
+	{
+		// remember last frame we read a dem_packet update
+		m_nTimeDemoCurrentFrame = host_framecount;
+	}
+	
+	int inseq, outseqack, outseq = 0;
+
+	m_DemoFile.ReadCmdInfo( m_LastCmdInfo );
+
+	m_DemoFile.ReadSequenceInfo( inseq, outseqack );
+	cl.m_NetChannel->SetSequenceData( outseq, inseq, outseqack );
+
+	int length = m_DemoFile.ReadRawData( (char*)m_DemoPacket.data,  NET_MAX_PAYLOAD );
+
+	if ( demo_debug.GetBool() )
+	{
+		Msg( "%d network packet [%d]\n", tick, length );
+	}
+
+	if ( length > 0 )
+	{
+		// succsessfully read new demopacket
+		m_DemoPacket.received = realtime;
+		m_DemoPacket.size = length;
+		m_DemoPacket.message.StartReading( m_DemoPacket.data,  m_DemoPacket.size );
+	
+		if ( demo_debug.GetInt() >= 1 )
+		{
+			Msg( "Demo message, tick %i, %i bytes\n", GetPlaybackTick(), length );
+		}
+	}
+
+	// Try and jump ahead one frame
+	m_bInterpolateView = ParseAheadForInterval( tick, 8 );
+
+	// ConMsg( "Reading message for %i : %f skip %i\n", m_nFrameCount, fElapsedTime, forceskip ? 1 : 0 );
+
+	// Skip a few ticks before doing any timing
+	if ( (m_nTimeDemoStartFrame < 0) && GetPlaybackTick() > 100 )
+	{
+		m_nTimeDemoStartFrame = host_framecount;
+		m_flTimeDemoStartTime = Sys_FloatTime();
+		m_flTotalFPSVariability = 0.0f;
+
+		if ( m_bTimeDemo )
+		{
+			g_EngineStats.BeginRun();
+		}
+	}
+
+	if ( m_nSnapshotTick > 0 && m_nSnapshotTick <= GetPlaybackTick() )
+	{
+		const char *filename = "benchframe";
+
+		if ( m_SnapshotFilename[0] )
+			filename = m_SnapshotFilename;
+
+		CL_TakeScreenshot( filename ); // take a screenshot
+		m_nSnapshotTick = 0;
+
+		if ( s_bBenchframe )
+		{
+			Cbuf_AddText( "stopdemo\n" );
+		}
+	}
+
+	return &m_DemoPacket;
+}
+
+void CDemoPlayer::InterpolateDemoCommand( int targettick, DemoCommandQueue& prev, DemoCommandQueue& next )
+{
+	CUtlVector< DemoCommandQueue >& list = m_DestCmdInfo;
+	int c = list.Count();
+
+	prev.info.Reset();
+	next.info.Reset();
+
+	if ( c < 2 )
+	{
+		// we need at least two entries to interpolate
+		return; 
+	}
+
+	int i = 0;
+	int savedI = -1;
+
+	DemoCommandQueue *entry1 = &list[ i ];
+	DemoCommandQueue *entry2 = &list[ i+1 ];
+
+	while ( true )
+	{
+		if ( (entry1->tick <= targettick) && (entry2->tick > targettick) )
+		{
+			// Means we hit a FDEMO_NOINTERP along the way to now
+			if ( savedI != -1 )
+			{
+				prev = list[ savedI ];
+				next = list[ savedI + 1 ];
+			}
+			else
+			{
+				prev = *entry1;
+				next = *entry2;
+			}
+			return;
+		}
+
+		// If any command between the previous target and now has the FDEMO_NOINTERP, we need to stop at the command just before that (entry), so we save off the I
+		// We can't just return since we need to see if we actually get to a spanning pair (though we always should).  Also, we only latch this final interp spot on
+		///  the first FDEMO_NOINTERP we see
+		if ( savedI == -1 &&
+			 entry2->tick > m_nPreviousTick &&
+			 entry2->tick <= targettick &&
+			 entry2->info.flags & FDEMO_NOINTERP )
+		{
+			savedI = i;
+		}
+
+		if ( i+2 == c )
+			break;
+
+		i++;
+		entry1 = &list[ i ];
+		entry2 = &list[ i+1 ];
+	}	
+
+	Assert( 0 );
+}
+
+static ConVar demo_legacy_rollback( "demo_legacy_rollback", "1", 0, "Use legacy view interpolation rollback amount in demo playback." );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CDemoPlayer::InterpolateViewpoint( void )
+{
+	if ( !IsPlayingBack() )
+		return;
+
+	democmdinfo_t outinfo;
+	outinfo.Reset();
+
+	bool bHasValidData =
+		 m_LastCmdInfo.viewOrigin != vec3_origin ||
+		 m_LastCmdInfo.viewAngles != vec3_angle ||
+		 m_LastCmdInfo.localViewAngles != vec3_angle ||
+		 m_LastCmdInfo.flags != 0;
+
+	int nTargetTick = GetPlaybackTick();
+
+	// Player view needs to be one tick interval in the past like the client DLL entities
+	if ( cl.m_nMaxClients == 1 )
+	{
+		if ( demo_legacy_rollback.GetBool() )
+		{
+			nTargetTick -= TIME_TO_TICKS( cl.GetClientInterpAmount() ) + 1;
+		}
+		else
+		{
+			nTargetTick -= 1;
+		}
+	}
+
+	float vel = 0.0f;
+	float angVel = 0.0f; 
+	if ( m_bInterpolateView && demo_interpolateview.GetBool() && bHasValidData )
+	{
+		DemoCommandQueue prev, next;
+		float frac = 0.0f;
+
+		prev.info = m_LastCmdInfo;
+		prev.tick = -1;
+		next.info = m_LastCmdInfo;
+		next.tick = -1;
+
+		// Determine current time slice
+		
+		InterpolateDemoCommand( nTargetTick, prev, next );
+
+		float dt = TICKS_TO_TIME(next.tick-prev.tick);
+
+		frac = (TICKS_TO_TIME(nTargetTick-prev.tick)+cl.m_tickRemainder)/dt;
+
+		frac = clamp( frac, 0.0f, 1.0f );
+
+		// Now interpolate
+		Vector delta;
+
+		Vector startorigin = prev.info.GetViewOrigin();
+		Vector destorigin = next.info.GetViewOrigin();
+
+		// check for teleporting - since there can be multiple cmd packets between a game frame,
+		// we need to check from the last actually ran command to see if there was a teleport
+		VectorSubtract( destorigin, m_LastCmdInfo.GetViewOrigin(), delta );
+		float distmoved = delta.Length();
+		
+		if ( dt > 0.0f )
+		{
+			vel = distmoved / dt;
+		}
+
+		if ( dt > 0.0f )
+		{
+			QAngle startang = prev.info.GetLocalViewAngles();
+			QAngle destang = next.info.GetLocalViewAngles();
+	
+			for ( int i = 0; i < 3; ++i )
+			{
+				float dAng = AngleNormalizePositive( destang[ i ] ) - AngleNormalizePositive( startang[ i ] );
+				dAng = AngleNormalize( dAng );
+				float aVel = fabs( dAng ) / dt;
+				if ( aVel > angVel )
+				{
+					angVel = aVel;
+				}
+			}
+		}
+
+		// FIXME: This should be velocity based maybe?
+		if ( (vel > demo_interplimit.GetFloat()) || 
+			 (angVel > demo_avellimit.GetFloat() ) ||
+			m_bResetInterpolation )
+		{
+			m_bResetInterpolation = false;
+
+			// it's a teleport, just let it happen naturally next frame
+			// setting frac to 1.0 (like it was previously) would just mean that we
+			// are teleporting a frame ahead of when we should
+			outinfo.viewOrigin = m_LastCmdInfo.GetViewOrigin();
+			outinfo.viewAngles = m_LastCmdInfo.GetViewAngles();
+			outinfo.localViewAngles = m_LastCmdInfo.GetLocalViewAngles();
+		}
+		else
+		{
+			outinfo.viewOrigin = startorigin + frac * ( destorigin - startorigin );
+
+			Quaternion src, dest;
+			Quaternion result;
+
+			AngleQuaternion( prev.info.GetViewAngles(), src );
+			AngleQuaternion( next.info.GetViewAngles(), dest );
+			QuaternionSlerp( src, dest, frac, result );
+
+			QuaternionAngles( result, outinfo.viewAngles );
+
+			AngleQuaternion( prev.info.GetLocalViewAngles(), src );
+			AngleQuaternion( next.info.GetLocalViewAngles(), dest );
+			QuaternionSlerp( src, dest, frac, result );
+
+			QuaternionAngles( result, outinfo.localViewAngles );
+		}
+	}
+	else if ( bHasValidData )
+	{
+		// don't interpolate, just copy values
+		outinfo.viewOrigin = m_LastCmdInfo.GetViewOrigin();
+		outinfo.viewAngles = m_LastCmdInfo.GetViewAngles();
+		outinfo.localViewAngles = m_LastCmdInfo.GetLocalViewAngles();
+	}
+
+	m_nPreviousTick = nTargetTick;
+
+	// let any demo system override view ( drive, editor, smoother etc)
+	bHasValidData |= OverrideView( outinfo );
+
+	if ( !bHasValidData )
+		return; // no validate data & no override, exit
+
+	g_pClientSidePrediction->SetViewOrigin( outinfo.viewOrigin );
+	g_pClientSidePrediction->SetViewAngles( outinfo.viewAngles );
+	g_pClientSidePrediction->SetLocalViewAngles( outinfo.localViewAngles );
+#ifndef SWDS
+	VectorCopy( outinfo.viewAngles, cl.viewangles );
+#endif
+
+	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CDemoPlayer::IsPlayingTimeDemo( void )
+{
+	return m_bTimeDemo && m_bPlayingBack;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CDemoPlayer::IsPlayingBack( void )
+{
+	return m_bPlayingBack;
+}
+
+CDemoPlayer::CDemoPlayer()
+{
+	m_flAutoResumeTime = 0.0f;
+	m_flPlaybackRateModifier = 1.0f;
+	m_bTimeDemo = false;	
+	m_nTimeDemoStartFrame = -1;	
+	m_flTimeDemoStartTime = 0.0f;	
+	m_flTotalFPSVariability = 0.0f;
+	m_nTimeDemoCurrentFrame = -1; 
+	m_bPlayingBack = false;
+	m_bLoading = false;
+	m_bPlaybackPaused = false;
+	m_nSkipToTick = -1;
+	m_nSkipPacketsPlayed = 0;
+	m_nSnapshotTick = 0;
+	m_SnapshotFilename[0] = 0;
+	m_bResetInterpolation = false;
+	m_nPreviousTick = 0;
+	m_nEndTick = 0;
+}
+
+CDemoPlayer::~CDemoPlayer()
+{
+	StopPlayback();
+	if ( g_ClientDLL )
+	{
+		g_ClientDLL->OnDemoPlaybackStop();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start's demo playback
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+bool CDemoPlayer::StartPlayback( const char *filename, bool bAsTimeDemo )
+{
+	m_bLoading = true;
+
+	SCR_BeginLoadingPlaque();
+
+	// Disconnect from server or stop running one
+	int oldn = cl.demonum;
+	cl.demonum = -1;
+	Host_Disconnect(false);
+	cl.demonum = oldn;
+
+	if ( !m_DemoFile.Open( filename, true )  )
+	{
+		cl.demonum = -1;		// stop demo loop
+		return false;
+	}
+
+	// Read in the m_DemoHeader
+	demoheader_t *dh = m_DemoFile.ReadDemoHeader();
+
+	if ( !dh )
+	{
+		ConMsg( "Failed to read demo header.\n" );
+		m_DemoFile.Close();
+		cl.demonum = -1;
+		return false;
+	}
+	
+	ConMsg ("Playing demo from %s.\n", filename);
+
+	// Now read in the directory structure.
+	m_bPlayingBack = true;
+	cl.m_nSignonState= SIGNONSTATE_CONNECTED;
+
+	ResyncDemoClock(); 
+
+	// create a fake channel with a NULL address
+	cl.m_NetChannel = NET_CreateNetChannel( NS_CLIENT, NULL, "DEMO", &cl, false, dh->networkprotocol );
+
+	if ( !cl.m_NetChannel )
+	{
+		ConMsg ("CDemo::Play: failed to create demo net channel\n" );
+		m_DemoFile.Close();
+		cl.demonum = -1;		// stop demo loop
+		Host_Disconnect(true);
+	}
+	
+	cl.m_NetChannel->SetTimeout( -1.0f );	// never timeout
+	
+	Q_memset( &m_DemoPacket, 0, sizeof(m_DemoPacket) );
+
+	// setup demo packet data buffer
+	m_DemoPacket.data = new unsigned char[NET_MAX_PAYLOAD];
+	m_DemoPacket.from.SetType( NA_LOOPBACK);
+		
+	cl.chokedcommands = 0;
+	cl.lastoutgoingcommand = -1;
+ 	cl.m_flNextCmdTime = net_time;
+
+	m_bTimeDemo = bAsTimeDemo;
+	m_nTimeDemoCurrentFrame = -1;
+	m_nTimeDemoStartFrame = -1;
+
+	if ( m_bTimeDemo )
+	{
+		SeedRandomNumberGenerator( true );
+	}
+
+	demoaction->StartPlaying( filename );
+
+	// m_bFastForwarding = false;
+	m_flAutoResumeTime = 0.0f;
+	m_flPlaybackRateModifier = 1.0f;
+
+	scr_demo_override_fov = 0.0f;
+
+	m_bLoading = false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : flCurTime - 
+//-----------------------------------------------------------------------------
+void CDemoPlayer::MarkFrame( float flFPSVariability )
+{
+	m_flTotalFPSVariability += flFPSVariability;
+}
+
+void CDemoPlayer::WriteTimeDemoResults( void )
+{
+	int		frames;
+	float	time;
+	frames = (host_framecount - m_nTimeDemoStartFrame) - 1;
+	time = Sys_FloatTime() - m_flTimeDemoStartTime;
+	if (!time)
+	{
+		time = 1;
+	}
+	float flVariability = (m_flTotalFPSVariability / (float)frames);
+	ConMsg ("%i frames %5.3f seconds %5.2f fps (%5.2f ms/f) %5.3f fps variability\n", frames, time, frames/time, 1000*time/frames, flVariability );
+	bool bFileExists = g_pFileSystem->FileExists( "SourceBench.csv" );
+	FileHandle_t fileHandle = g_pFileSystem->Open( "SourceBench.csv", "a+" );
+	int width, height;
+	CMatRenderContextPtr pRenderContext( materials );
+	pRenderContext->GetWindowSize( width, height );
+
+	const MaterialSystem_Config_t &config = materials->GetCurrentConfigForVideoCard();
+
+	if( !bFileExists )
+	{
+		g_pFileSystem->FPrintf( fileHandle, "demofile," );
+		g_pFileSystem->FPrintf( fileHandle, "fps," );
+		g_pFileSystem->FPrintf( fileHandle, "framerate variability," );
+		g_pFileSystem->FPrintf( fileHandle, "totaltime," );
+		g_pFileSystem->FPrintf( fileHandle, "numframes," );
+		g_pFileSystem->FPrintf( fileHandle, "width," );
+		g_pFileSystem->FPrintf( fileHandle, "height," );
+		g_pFileSystem->FPrintf( fileHandle, "windowed," );
+		g_pFileSystem->FPrintf( fileHandle, "vsync," );
+		g_pFileSystem->FPrintf( fileHandle, "MSAA," );
+		g_pFileSystem->FPrintf( fileHandle, "Aniso," );
+		g_pFileSystem->FPrintf( fileHandle, "dxlevel," );
+		g_pFileSystem->FPrintf( fileHandle, "cmdline," );
+		g_pFileSystem->FPrintf( fileHandle, "driver name," );
+		g_pFileSystem->FPrintf( fileHandle, "vendor id," );
+		g_pFileSystem->FPrintf( fileHandle, "device id," );
+
+//		g_pFileSystem->FPrintf( fileHandle, "sound," );
+		g_pFileSystem->FPrintf( fileHandle, "Reduce fillrate," );
+		g_pFileSystem->FPrintf( fileHandle, "reflect entities," );
+		g_pFileSystem->FPrintf( fileHandle, "motion blur," );
+		g_pFileSystem->FPrintf( fileHandle, "flashlight shadows," );
+		g_pFileSystem->FPrintf( fileHandle, "mat_reduceparticles," );
+		g_pFileSystem->FPrintf( fileHandle, "r_dopixelvisibility," );
+		g_pFileSystem->FPrintf( fileHandle, "nulldevice," );
+		g_pFileSystem->FPrintf( fileHandle, "timedemo_comment," );
+		g_pFileSystem->FPrintf( fileHandle, "\n" );
+	}
+
+	ConVarRef mat_vsync( "mat_vsync" );
+	ConVarRef mat_antialias( "mat_antialias" );
+	ConVarRef mat_forceaniso( "mat_forceaniso" );
+	ConVarRef r_waterforcereflectentities( "r_waterforcereflectentities" );
+	ConVarRef mat_motion_blur_enabled( "mat_motion_blur_enabled" );
+	ConVarRef r_flashlightdepthtexture( "r_flashlightdepthtexture" );
+	ConVarRef mat_reducefillrate( "mat_reducefillrate" );
+	ConVarRef mat_reduceparticles( "mat_reduceparticles" );
+	ConVarRef r_dopixelvisibility( "r_dopixelvisibility" );
+
+	g_pFileSystem->Seek( fileHandle, 0, FILESYSTEM_SEEK_TAIL );
+	MaterialAdapterInfo_t info;
+	materials->GetDisplayAdapterInfo( materials->GetCurrentAdapter(), info );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", m_DemoFile.m_szFileName );
+	g_pFileSystem->FPrintf( fileHandle, "%5.1f,", frames/time );
+	g_pFileSystem->FPrintf( fileHandle, "%5.1f,", flVariability );
+	g_pFileSystem->FPrintf( fileHandle, "%5.1f,", time );
+	g_pFileSystem->FPrintf( fileHandle, "%i,", frames );
+	g_pFileSystem->FPrintf( fileHandle, "%i,", width );
+	g_pFileSystem->FPrintf( fileHandle, "%i,", height );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", config.Windowed() ? "windowed" : "fullscreen");
+	g_pFileSystem->FPrintf( fileHandle, "%s,", mat_vsync.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%d,", mat_antialias.GetInt() );
+	g_pFileSystem->FPrintf( fileHandle, "%d,", mat_forceaniso.GetInt() );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", COM_DXLevelToString( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() ) );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", CommandLine()->GetCmdLine() );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", info.m_pDriverName );
+	g_pFileSystem->FPrintf( fileHandle, "0x%x,", info.m_VendorID );
+	g_pFileSystem->FPrintf( fileHandle, "0x%x,", info.m_DeviceID );
+
+//	g_pFileSystem->FPrintf( fileHandle, "%s,", CommandLine()->CheckParm( "-nosound" ) ? "off" : "on" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", mat_reducefillrate.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", r_waterforcereflectentities.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", mat_motion_blur_enabled.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", r_flashlightdepthtexture.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", mat_reduceparticles.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", r_dopixelvisibility.GetBool() ? "on" : "off" );
+	g_pFileSystem->FPrintf( fileHandle, "%s,", CommandLine()->CheckParm( "-nulldevice" ) ? "yes" : "no" );
+
+	int itimedemo_comment = CommandLine()->FindParm( "-timedemo_comment" );
+	const char *timedemo_comment = itimedemo_comment ? CommandLine()->GetParm( itimedemo_comment + 1 ) : "";
+	g_pFileSystem->FPrintf( fileHandle, "%s,", timedemo_comment );
+	g_pFileSystem->FPrintf( fileHandle, "\n" );
+	g_pFileSystem->Close( fileHandle );
+}
+
+
+void CDemoPlayer::PausePlayback( float seconds  )
+{
+	m_bPlaybackPaused = true;
+	
+	if ( seconds > 0.0f )
+	{
+		// Use true clock since everything else is frozen
+		m_flAutoResumeTime = Sys_FloatTime() + seconds;
+	}
+	else
+	{
+		m_flAutoResumeTime = 0.0f;
+	}
+}
+
+void CDemoPlayer::ResumePlayback()
+{
+	m_bPlaybackPaused = false;
+	m_flAutoResumeTime = 0.0f;
+}
+
+bool CDemoPlayer::CheckPausedPlayback()
+{
+	if ( demo_pauseatservertick.GetInt() > 0 )
+	{
+		if ( cl.GetServerTickCount() >= demo_pauseatservertick.GetInt() )
+		{
+			PausePlayback( -1 );
+			ETWMark1I( "DemoPlayer: Reached pause tick", cl.GetServerTickCount() );
+			m_nSkipToTick = -1;
+			demo_pauseatservertick.SetValue( 0 );
+			Msg( "Demo paused at server tick %i\n", cl.GetServerTickCount() );
+		}
+	}
+	
+	if ( IsSkipping() )
+	{
+		if ( ( m_nSkipToTick > GetPlaybackTick() ) ||
+			 ( ( m_nSkipToTick & SKIP_TO_TICK_FLAG ) == SKIP_TO_TICK_FLAG ) )
+		{
+			// we are skipping
+			return false;
+		}
+		else
+		{
+			// we can't skip back (or finished skipping), so disable skipping
+			ETWMark1I( "DemoPlayer: SkipToTick done", GetPlaybackTick() );
+			m_nSkipToTick = -1;
+		}
+	}
+
+	if ( !IsPlaybackPaused() )
+		return false;
+
+	if ( m_bPlaybackPaused )
+	{
+		if ( (m_flAutoResumeTime > 0.0f) &&
+			 (Sys_FloatTime() >= m_flAutoResumeTime) )
+		{
+			// it's time to unpause replay
+			ResumePlayback();
+		}
+	}
+
+	return m_bPlaybackPaused;
+}
+
+bool CDemoPlayer::IsPlaybackPaused()
+{
+	if ( !IsPlayingBack() )
+		return false;
+
+	// never pause while reading signon data
+	if ( m_nTimeDemoCurrentFrame < 0 )
+		return false;
+
+	// If skipping then do not pretend paused
+	if ( IsSkipping() )
+		return false;
+	
+	return m_bPlaybackPaused;
+}
+
+int CDemoPlayer::GetPlaybackStartTick( void )
+{
+	return m_nStartTick;
+}
+
+int CDemoPlayer::GetPlaybackTick( void )
+{
+	return host_tickcount - m_nStartTick;
+}
+
+void CDemoPlayer::ResyncDemoClock()
+{
+	m_nStartTick = host_tickcount;
+	m_nPreviousTick = m_nStartTick;
+}
+
+float CDemoPlayer::GetPlaybackTimeScale()
+{
+	return m_flPlaybackRateModifier;
+}
+
+void CDemoPlayer::SetPlaybackTimeScale(float timescale)
+{
+	m_flPlaybackRateModifier = timescale;
+}
+
+void CDemoPlayer::SetBenchframe( int tick, const char *filename )
+{
+	m_nSnapshotTick = tick;
+
+	if ( filename )
+	{
+		Q_strncpy( m_SnapshotFilename, filename, sizeof(m_SnapshotFilename) );
+	}
+}
+
+static bool ComputeNextIncrementalDemoFilename( char *name, int namesize )
+{
+	FileHandle_t test;
+	
+	test = g_pFileSystem->Open( name, "rb" );
+	if ( FILESYSTEM_INVALID_HANDLE == test )
+	{
+		// file doesn't exist, so we can use that 
+		return true;
+	}
+	g_pFileSystem->Close( test );
+
+	char basename[ MAX_OSPATH ];
+
+	Q_StripExtension( name, basename, sizeof( basename ) );
+
+	// Start looking for a valid name
+	int i = 0;
+	for ( i = 0; i < 1000; i++ )
+	{
+		char newname[ MAX_OSPATH ];
+		Q_snprintf( newname, sizeof( newname ), "%s%03i.dem", basename, i );
+
+		test = g_pFileSystem->Open( newname, "rb" );
+		if ( FILESYSTEM_INVALID_HANDLE == test )
+		{
+			Q_strncpy( name, newname, namesize );
+			return true;
+		}
+		g_pFileSystem->Close( test );
+	}
+
+	ConMsg( "Unable to find a valid incremental demo filename for %s, try clearing the directory of %snnn.dem\n", name, basename );
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: List the contents of a demo file.
+//-----------------------------------------------------------------------------
+void CL_ListDemo_f( const CCommand &args )
+{
+	if ( cmd_source != src_command )
+		return;
+
+	// Find the file
+	char name[MAX_OSPATH];
+
+	Q_snprintf (name, sizeof(name), "%s", args[1]);
+	
+	Q_DefaultExtension( name, ".dem", sizeof( name ) );
+
+	ConMsg ("Demo contents for %s:\n", name);
+
+	CDemoFile demofile;
+
+	if ( !demofile.Open( name, true ) )
+	{
+		ConMsg ("ERROR: couldn't open.\n");
+		return;
+	}
+
+	demofile.ReadDemoHeader();
+
+	demoheader_t *header = &demofile.m_DemoHeader;
+
+	if ( !header )
+	{
+		ConMsg( "Failed reading demo header.\n" );
+		demofile.Close();
+		return;
+	}
+	
+	if ( Q_strcmp ( header->demofilestamp, DEMO_HEADER_ID ) )
+	{
+		ConMsg( "%s is not a valid demo file\n", name);
+		return;
+	}
+
+	ConMsg("Network protocol: %i\n", header->networkprotocol);
+	ConMsg("Demo version    : %i\n", header->demoprotocol);
+	ConMsg("Server name     : %s\n", header->servername);
+	ConMsg("Map name        : %s\n", header->mapname);
+	ConMsg("Game            : %s\n", header->gamedirectory);
+	ConMsg("Player name     : %s\n", header->clientname);
+	ConMsg("Time            : %.1f\n", header->playback_time);
+	ConMsg("Ticks           : %i\n", header->playback_ticks);
+	ConMsg("Frames          : %i\n", header->playback_frames);
+	ConMsg("Signon size     : %i\n", header->signonlength);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CON_COMMAND( stop, "Finish recording demo." )
+{
+	if ( cmd_source != src_command )
+		return;
+
+	if ( !demorecorder->IsRecording() )
+	{
+		ConDMsg ("Not recording a demo.\n");
+		return;
+	}
+
+	demorecorder->StopRecording();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CON_COMMAND_F( record, "Record a demo.", FCVAR_DONTRECORD )
+{
+	if ( g_ClientDLL == NULL )
+	{
+		ConMsg ("Can't record on dedicated server.\n");
+		return;
+	}	
+
+	if ( args.ArgC() != 2 && args.ArgC() != 3 )
+	{
+		ConMsg ("record <demoname> [incremental]\n");
+		return;
+	}
+
+	bool incremental = false;
+	if ( args.ArgC() == 3 )
+	{
+		if ( !Q_stricmp( args[2], "incremental" ) )
+		{
+			incremental = true;
+		}
+	}
+	
+	if ( demorecorder->IsRecording() )
+	{
+		ConMsg ("Already recording.\n");
+		return;
+	}
+
+	if ( demoplayer->IsPlayingBack() )
+	{
+		ConMsg ("Can't record during demo playback.\n");
+		return;
+	}
+
+	// check path first
+	if ( !COM_IsValidPath( args[1] ) )
+	{
+		ConMsg( "record %s: invalid path.\n", args[1] );
+		return;
+	}
+
+	char	name[ MAX_OSPATH ];
+
+	if ( !g_ClientDLL->CanRecordDemo( name, sizeof( name ) ) )
+	{
+		ConMsg( "%s\n", name );	// re-use name as the error string if the client prevents us from starting a demo
+		return;
+	}
+
+	// remove .dem extension if user added it
+	Q_StripExtension( args[1], name, sizeof( name ) );
+	
+	if ( incremental )
+	{
+		// If file exists, construct a better name
+		if ( !ComputeNextIncrementalDemoFilename( name, sizeof( name ) ) )
+		{
+			return;
+		}
+	}
+	// Record it
+	demorecorder->StartRecording( name, incremental );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CL_PlayDemo_f( const CCommand &args )
+{
+	if ( cmd_source != src_command )
+		return;
+
+	if ( args.ArgC() != 2 )
+	{
+		ConMsg ("playdemo <demoname> : plays a demo file\n");
+		return;
+	}
+
+	// Get the demo filename
+	char name[ MAX_OSPATH ];
+	Q_strncpy( name, args[1], sizeof( name ) );
+	Q_DefaultExtension( name, ".dem", sizeof( name ) );
+
+	// set current demo player to replay demo player?
+	demoplayer = g_pClientDemoPlayer;
+
+	//
+	// open the demo file
+	//
+	if ( demoplayer->StartPlayback( name, false ) )
+	{
+		// Remove extension
+		char basename[ MAX_OSPATH ];
+		V_StripExtension( name, basename, sizeof( basename ) );
+		g_ClientDLL->OnDemoPlaybackStart( basename );
+	}
+	else
+	{
+		SCR_EndLoadingPlaque();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CL_TimeDemo_f( const CCommand &args )
+{
+	if ( cmd_source != src_command )
+		return;
+
+	if ( args.ArgC() < 2 || args.ArgC() > 4 )
+	{
+		ConMsg ("timedemo <demoname> <optional stats.txt> : gets demo speeds, starting from optional frame\n");
+		return;
+	}
+
+	if( args.ArgC() >= 3 )
+	{
+		Q_strncpy( g_pStatsFile, args[ 2 ], sizeof( g_pStatsFile ) );
+	}
+	else
+	{
+		Q_strncpy( g_pStatsFile, "UNKNOWN", sizeof( g_pStatsFile ) );
+	}
+
+	// set current demo player to client demo player
+	demoplayer = g_pClientDemoPlayer;
+	
+	// open the demo file
+	char name[ MAX_OSPATH ];
+	Q_strncpy (name, args[1], sizeof( name ) );
+	Q_DefaultExtension( name, ".dem", sizeof( name ) );
+
+	if ( !demoplayer->StartPlayback( name, true ) )
+	{
+		SCR_EndLoadingPlaque();
+	}
+}
+
+void CL_TimeDemoQuit_f( const CCommand &args )
+{
+	demo_quitafterplayback.SetValue( 1 );
+	CL_TimeDemo_f( args );
+}
+
+void CL_BenchFrame_f( const CCommand &args )
+{
+	if ( cmd_source != src_command )
+		return;
+
+	if ( args.ArgC() != 4 )
+	{
+		ConMsg ("benchframe <demoname> <frame> <tgafilename>: takes a snapshot of a particular frame in a demo\n");
+		return;
+	}
+
+	g_pClientDemoPlayer->SetBenchframe( max( 0, atoi( args[2] ) ), args[3] );
+
+	s_bBenchframe = true;
+
+	mat_norendering.SetValue( 1 );
+	
+	// set current demo player to client demo player
+	demoplayer = g_pClientDemoPlayer;
+	
+	// open the demo file
+	char name[ MAX_OSPATH ];
+	Q_strncpy (name, args[1], sizeof( name ) );
+	Q_DefaultExtension( name, ".dem", sizeof( name ) );
+
+	if ( !demoplayer->StartPlayback( name, true ) )
+	{
+		SCR_EndLoadingPlaque();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CON_COMMAND( vtune, "Controls VTune's sampling." )
+{
+ 	if ( args.ArgC() != 2 )
+	{
+		ConMsg ("vtune \"pause\" | \"resume\" : Suspend or resume VTune's sampling.\n");
+		return;
+	}
+	
+	if( !Q_strcasecmp( args[1], "pause" ) )
+	{
+		if(!vtune(false))
+		{
+			ConMsg("Failed to find \"VTPause()\" in \"vtuneapi.dll\".\n");
+			return;
+		}
+
+		ConMsg("VTune sampling paused.\n");
+	}
+
+	else if( !Q_strcasecmp( args[1], "resume" ) )
+	{
+		if(!vtune(true))
+		{
+			ConMsg("Failed to find \"VTResume()\" in \"vtuneapi.dll\".\n");
+			return;
+		}
+		
+		ConMsg("VTune sampling resumed.\n");
+	}
+
+	else
+	{
+		ConMsg("Unknown vtune option.\n");
+	}
+
+}
+
+
+
+CON_COMMAND_AUTOCOMPLETEFILE( playdemo, CL_PlayDemo_f, "Play a recorded demo file (.dem ).", NULL, dem );
+CON_COMMAND_AUTOCOMPLETEFILE( timedemo, CL_TimeDemo_f, "Play a demo and report performance info.", NULL, dem );
+CON_COMMAND_AUTOCOMPLETEFILE( timedemoquit, CL_TimeDemoQuit_f, "Play a demo, report performance info, and then exit", NULL, dem );
+CON_COMMAND_AUTOCOMPLETEFILE( listdemo, CL_ListDemo_f, "List demo file contents.", NULL, dem );
+CON_COMMAND_AUTOCOMPLETEFILE( benchframe, CL_BenchFrame_f, "Takes a snapshot of a particular frame in a time demo.", NULL, dem );
+
+CON_COMMAND( demo_pause, "Pauses demo playback." )
+{
+	float seconds = -1.0;
+
+	if ( args.ArgC() == 2 )
+	{
+		seconds = atof( args[1] );
+	}
+
+	demoplayer->PausePlayback( seconds );
+}
+
+CON_COMMAND( demo_resume, "Resumes demo playback." )
+{
+	demoplayer->ResumePlayback();
+}
+
+CON_COMMAND( demo_togglepause, "Toggles demo playback." )
+{
+	if ( !demoplayer->IsPlayingBack() )
+		return;
+	
+	if ( demoplayer->IsPlaybackPaused() )
+	{
+		demoplayer->ResumePlayback();
+	}
+	else
+	{
+		demoplayer->PausePlayback( -1 );
+	}
+}
+
+CON_COMMAND( demo_gototick, "Skips to a tick in demo." )
+{
+	bool bRelative = false;
+	bool bPause = false;
+
+	if ( args.ArgC() < 2 )
+	{
+		Msg("Syntax: demo_gototick <tick> [relative] [pause]\n");
+		return;
+	}
+	
+	int nTick = atoi( args[1] );
+	
+	if ( args.ArgC() >= 3 )
+	{
+		bRelative = Q_atoi( args[2] ) != 0;
+	}
+
+	if ( args.ArgC() >= 4 )
+	{
+		bPause = Q_atoi( args[3] ) != 0;
+	}
+
+	demoplayer->SkipToTick( nTick, bRelative, bPause );
+}
+
+CON_COMMAND( demo_setendtick, "Sets end demo playback tick. Set to 0 to disable." )
+{
+	if ( args.ArgC() != 2 )
+	{
+		Msg( "Syntax: demo_setendtick <tick>\n" );
+		return;
+	}
+
+	int nTick = atoi( args[1] );
+
+	demoplayer->SetEndTick( nTick );
+}
+
+CON_COMMAND( demo_timescale, "Sets demo replay speed." )
+{
+	float fScale = 1.0f;
+
+	if ( args.ArgC() == 2 )
+	{
+		fScale = atof( args[1] );
+		fScale = clamp( fScale, 0.0f, 100.0f );
+	}
+
+	demoplayer->SetPlaybackTimeScale( fScale );
+}
+
+bool CDemoPlayer::OverrideView( democmdinfo_t& info )
+{
+	if ( g_pDemoUI && g_pDemoUI->OverrideView( info, GetPlaybackTick() ) )
+		return true;
+
+	if ( g_pDemoUI2 && g_pDemoUI2->OverrideView( info, GetPlaybackTick() ) )
+		return true;
+
+	if ( demoaction && demoaction->OverrideView( info, GetPlaybackTick() ) )
+		return true;
+
+	return false;
+}
+
+void CDemoPlayer::OnStopCommand()
+{
+	cl.Disconnect( "Demo stopped", true);
+}
+
+void CDemoPlayer::ResetDemoInterpolation( void )
+{
+	m_bResetInterpolation = true;
+}
+
+int CDemoPlayer::GetProtocolVersion()
+{
+	Assert( IsPlayingBack() );
+	if ( !IsPlayingBack() )
+		return PROTOCOL_VERSION;
+
+	return m_DemoFile.GetProtocolVersion();
+}