source-engine/engine/demofile.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//===========================================================================//

#include <tier0/dbg.h>
#include <tier1/strtools.h>
#include <utlbuffer.h>

#include "demofile.h"
#include "filesystem_engine.h"
#include "demo.h"
#include "proto_version.h"
#include "convar.h"	// For dbg_demofile

// NOTE: This has to be the last file included!
#include "tier0/memdbgon.h"


void Host_EndGame (bool bShowMainMenu, const char *message, ...);

// Debug helpers - this class prints in a nested format
ConVar dbg_demofile( "dbg_demofile", "0", FCVAR_DEVELOPMENTONLY | FCVAR_HIDDEN );
//#define DEMOFILE_DBG_PRINT
#if defined( DEMOFILE_DBG_PRINT )
class CDbgPrint
{
public:
	static int s_nIndent;
	CDbgPrint( const char *pMsg )
	{
		++s_nIndent;
		if ( dbg_demofile.GetInt() )
		{
			for (int i = 0; i < 3*s_nIndent; ++i)
				DevMsg(" ");
			DevMsg( pMsg );
		}
	}
	~CDbgPrint() { --s_nIndent; }
};
int CDbgPrint::s_nIndent = 0;
#define DemoFileDbg(_txt) CDbgPrint printer( _txt )
#else
#define DemoFileDbg(_txt) (void)0
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDemoFile::CDemoFile() :
	m_pBuffer( NULL ),
	m_bAllowHeaderWrite( true ),
	m_bIsStreamBuffer( false )
{
}

CDemoFile::~CDemoFile()
{
	if ( IsOpen() )
	{
		Close();
	}
}

void CDemoFile::WriteSequenceInfo(int nSeqNrIn, int nSeqNrOut)
{
	DemoFileDbg( "WriteSequenceInfo()\n" );
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	m_pBuffer->PutInt( nSeqNrIn );
	m_pBuffer->PutInt( nSeqNrOut );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDemoFile::ReadSequenceInfo(int &nSeqNrIn, int &nSeqNrOut)
{
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	nSeqNrIn = m_pBuffer->GetInt( );
	nSeqNrOut = m_pBuffer->GetInt( );
}


inline void ByteSwap_democmdinfo_t( democmdinfo_t &swap )
{
	swap.flags = LittleDWord( swap.flags );

	LittleFloat( &swap.viewOrigin.x, &swap.viewOrigin.x );
	LittleFloat( &swap.viewOrigin.y, &swap.viewOrigin.y );
	LittleFloat( &swap.viewOrigin.z, &swap.viewOrigin.z );

	LittleFloat( &swap.viewAngles.x, &swap.viewAngles.x );
	LittleFloat( &swap.viewAngles.y, &swap.viewAngles.y );
	LittleFloat( &swap.viewAngles.z, &swap.viewAngles.z );

	LittleFloat( &swap.localViewAngles.x, &swap.localViewAngles.x );
	LittleFloat( &swap.localViewAngles.y, &swap.localViewAngles.y );
	LittleFloat( &swap.localViewAngles.z, &swap.localViewAngles.z );

	LittleFloat( &swap.viewOrigin2.x, &swap.viewOrigin2.x );
	LittleFloat( &swap.viewOrigin2.y, &swap.viewOrigin2.y );
	LittleFloat( &swap.viewOrigin2.z, &swap.viewOrigin2.z );

	LittleFloat( &swap.viewAngles2.x, &swap.viewAngles2.x );
	LittleFloat( &swap.viewAngles2.y, &swap.viewAngles2.y );
	LittleFloat( &swap.viewAngles2.z, &swap.viewAngles2.z );

	LittleFloat( &swap.localViewAngles2.x, &swap.localViewAngles2.x );
	LittleFloat( &swap.localViewAngles2.y, &swap.localViewAngles2.y );
	LittleFloat( &swap.localViewAngles2.z, &swap.localViewAngles2.z );
}

void CDemoFile::WriteCmdInfo( democmdinfo_t& info )
{
	DemoFileDbg( "WriteCmdInfo()\n" );
	democmdinfo_t littleEndianInfo = info;
	ByteSwap_democmdinfo_t( littleEndianInfo );

	Assert( m_pBuffer && m_pBuffer->IsValid() );
	m_pBuffer->Put( &littleEndianInfo, sizeof(democmdinfo_t) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDemoFile::ReadCmdInfo( democmdinfo_t& info )
{
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	m_pBuffer->Get( &info, sizeof(democmdinfo_t) );

	ByteSwap_democmdinfo_t( info );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : cmd - 
//			*fp - 
//-----------------------------------------------------------------------------
void CDemoFile::WriteCmdHeader( unsigned char cmd, int tick )
{
	if ( dbg_demofile.GetInt() ) DevMsg( "----------------------------------------\n" );
	Assert( cmd >= dem_signon && cmd <= dem_lastcmd );

	Assert( m_pBuffer && m_pBuffer->IsValid() );
	m_pBuffer->PutUnsignedChar( cmd );
	m_pBuffer->PutInt( tick );

	static const char *cmdname[] = 
	{
		"dem_unknown",
		"dem_signon",
		"dem_packet",
		"dem_synctick",
		"dem_consolecmd",
		"dem_usercmd",
		"dem_datatables",
		"dem_stop",
		"dem_stringtables"
	};

	DemoFileDbg( "WriteCmdHeader()..." );
	if ( dbg_demofile.GetInt() ) DevMsg( "tick %i, cmd %s \n", tick, cmdname[cmd] );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : cmd - 
//			dt - 
//			frame - 
//-----------------------------------------------------------------------------
void CDemoFile::ReadCmdHeader( unsigned char& cmd, int& tick )
{
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	cmd = m_pBuffer->GetUnsignedChar( );
	if ( !m_pBuffer || !m_pBuffer->IsValid() )
	{
		ConDMsg("Missing end tag in demo file.\n");
		cmd = dem_stop;
		return;
	}

	if ( cmd <= 0 || cmd > dem_lastcmd )
	{
		ConDMsg("Unexepcted command token [%d] in .demo file\n", cmd );
		cmd = dem_stop;
		return;
	}

	tick = m_pBuffer->GetInt( );
}

void CDemoFile::WriteConsoleCommand( const char *cmdstring, int tick )
{
	DemoFileDbg( "WriteConsoleCommand()\n" );
	if ( !cmdstring || !cmdstring[0] )
		return;

	if ( !m_pBuffer || !m_pBuffer->IsValid() )
		return;

	int len = Q_strlen( cmdstring ) + 1;
	if ( len >= 1024 )
	{
		DevMsg("CDemoFile::WriteConsoleCommand: command too long (>1024).\n");
		return;
	}

	WriteCmdHeader( dem_consolecmd, tick );

	WriteRawData( cmdstring, len );
}

const char *CDemoFile::ReadConsoleCommand()
{
	static char cmdstring[1024];
	
	ReadRawData( cmdstring, sizeof(cmdstring) );

	return cmdstring;
}

unsigned int CDemoFile::GetCurPos( bool bRead )
{
	if ( !m_pBuffer || !m_pBuffer->IsValid() )
		return 0;
	if ( bRead )
		return m_pBuffer->TellGet();
	return m_pBuffer->TellPut();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : buf - 
//-----------------------------------------------------------------------------
void CDemoFile::WriteNetworkDataTables( bf_write *buf, int tick  )
{
	DemoFileDbg( "WriteNetworkDataTables()\n" );
	MEM_ALLOC_CREDIT();

	if ( !m_pBuffer || !m_pBuffer->IsValid() )
	{
		DevMsg("CDemoFile::WriteNetworkDataTables: Haven't opened file yet!\n" );
		return;
	}

	WriteCmdHeader( dem_datatables, tick );

	WriteRawData( (char*)buf->GetBasePointer(), buf->GetNumBytesWritten() );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : expected_length - 
//			&demofile - 
//-----------------------------------------------------------------------------
int CDemoFile::ReadNetworkDataTables( bf_read *buf )
{
	if ( buf )
		return ReadRawData( (char*)buf->GetBasePointer(), buf->GetNumBytesLeft() );
	return ReadRawData( NULL, 0 ); // skip data
}

void CDemoFile::WriteStringTables( bf_write *buf, int tick )
{
	DemoFileDbg( "WriteStringTables()\n" );
	MEM_ALLOC_CREDIT();

	if ( !m_pBuffer || !m_pBuffer->IsValid() )
	{
		DevMsg("CDemoFile::WriteStringTables: Haven't opened file yet!\n" );
		return;
	}

	WriteCmdHeader( dem_stringtables, tick );

	WriteRawData( (char*)buf->GetBasePointer(), buf->GetNumBytesWritten() );
}

int CDemoFile::ReadStringTables( bf_read *buf )
{
	if ( buf )
		return ReadRawData( (char*)buf->GetBasePointer(), buf->GetNumBytesLeft() );
	return ReadRawData( NULL, 0 ); // skip data
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : cmdnumber - 
//-----------------------------------------------------------------------------
void CDemoFile::WriteUserCmd( int cmdnumber, const char *buffer, unsigned char bytes, int tick )
{
	DemoFileDbg( "WriteUserCmd()\n" );
	if ( !m_pBuffer || !m_pBuffer->IsValid() )
		return;

	WriteCmdHeader( dem_usercmd, tick );

	m_pBuffer->PutInt( cmdnumber );

	WriteRawData( buffer, bytes );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : discard - 
//-----------------------------------------------------------------------------
int CDemoFile::ReadUserCmd( char *buffer, int &size )
{
	int outgoing_sequence;
	
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	outgoing_sequence = m_pBuffer->GetInt();

	size = ReadRawData( buffer, size );
	return outgoing_sequence;
}

//
// Purpose: Rewind from the current spot by the time stamp, byte code and frame counter offsets
//-----------------------------------------------------------------------------
void CDemoFile::SeekTo( int position, bool bRead )
{
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	if ( bRead )
	{
		m_pBuffer->SeekGet( CUtlBuffer::SEEK_HEAD, position );
	}
	else
	{
		m_pBuffer->SeekPut( CUtlBuffer::SEEK_HEAD, position );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
int CDemoFile::ReadRawData( char *buffer, int length )
{
	int size;
	
	Assert( m_pBuffer && m_pBuffer->IsValid() );
	if ( !m_pBuffer || !m_pBuffer->IsValid() )
	{
		Host_EndGame(true, "Error reading demo message data.\n");
		return -1;
	}

	size = m_pBuffer->GetInt();

	if ( !buffer )
	{
		// just skip it
		m_pBuffer->SeekGet( CUtlBuffer::SEEK_CURRENT, size );
		return size;
	}

	if ( length < size )
	{
		// given buffer is too small
		DevMsg("CDemoFile::ReadRawData: buffer overflow (%i).\n", size );
		m_pBuffer->SeekGet( CUtlBuffer::SEEK_CURRENT, -(int)sizeof( int ) ); // rewind our get pointer
		return -1;
	}

	// read data into buffer
	m_pBuffer->Get( buffer, size );

	return size;
}

void CDemoFile::WriteRawData( const char *buffer, int length )
{
	DemoFileDbg( "WriteRawData()\n" );
	MEM_ALLOC_CREDIT();

	Assert( m_pBuffer && m_pBuffer->IsValid() );
	m_pBuffer->PutInt( length );
	m_pBuffer->Put( buffer, length );
}

void CDemoFile::WriteDemoHeader()
{
	if ( !m_bAllowHeaderWrite )
		return;

	DemoFileDbg( "WriteDemoHeader()\n" );
	Assert( m_DemoHeader.networkprotocol == PROTOCOL_VERSION );

	if ( dbg_demofile.GetInt() )
	{
		DevMsg( "\n" );
		DevMsg( "     demofilestamp: %s\n", m_DemoHeader.demofilestamp );
		DevMsg( "     demoprotocol (should be %i): %i\n", DEMO_PROTOCOL, m_DemoHeader.demoprotocol );
		DevMsg( "     networkprotocol (should be %i): %i\n", PROTOCOL_VERSION, m_DemoHeader.networkprotocol );
		DevMsg( "     servername: %s\n", m_DemoHeader.servername );
		DevMsg( "     clientname: %s\n", m_DemoHeader.clientname );
		DevMsg( "     mapname: %s\n", m_DemoHeader.mapname );
		DevMsg( "     gamedirectory: %s\n", m_DemoHeader.gamedirectory );
		DevMsg( "     playback_time: %f\n", m_DemoHeader.playback_time );
		DevMsg( "     playback_ticks: %i\n", m_DemoHeader.playback_ticks );	
		DevMsg( "     playback_frames: %i\n", m_DemoHeader.playback_frames );
		DevMsg( "     signonlength: %i\n", m_DemoHeader.signonlength );
		DevMsg( "\n" );
	}

	// Swaps endianness, goes to file start and writes header
	demoheader_t littleEndianHeader = *((demoheader_t*)&m_DemoHeader);
	ByteSwap_demoheader_t( littleEndianHeader );

	// Goto file start
	m_pBuffer->SeekPut( CUtlBuffer::SEEK_HEAD, 0 );

	// Write
	m_pBuffer->Put( &m_DemoHeader, sizeof( m_DemoHeader ) );
}

demoheader_t *CDemoFile::ReadDemoHeader()
{
	bool bOk;
	Q_memset( &m_DemoHeader, 0, sizeof(m_DemoHeader) );

	if ( !m_pBuffer || !m_pBuffer->IsValid() )
		return NULL;
	m_pBuffer->SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
	m_pBuffer->Get( &m_DemoHeader, sizeof(demoheader_t) );
	bOk = m_pBuffer->IsValid();

	ByteSwap_demoheader_t( m_DemoHeader );

	if ( !bOk )
		return NULL;  // reading failed

	if ( Q_strcmp( m_DemoHeader.demofilestamp, DEMO_HEADER_ID ) )
	{
		ConMsg( "%s has invalid demo header ID.\n", m_szFileName );
		return NULL;
	}

	if ( m_DemoHeader.networkprotocol != PROTOCOL_VERSION 
#if defined( DEMO_BACKWARDCOMPATABILITY )
		&&  m_DemoHeader.networkprotocol < PROTOCOL_VERSION_12 
#endif
		)
	{
		ConMsg ("ERROR: demo network protocol %i outdated, engine version is %i \n", 
			m_DemoHeader.networkprotocol, PROTOCOL_VERSION );

		return NULL;
	}

	if ( ( m_DemoHeader.demoprotocol > DEMO_PROTOCOL) ||
		 ( m_DemoHeader.demoprotocol < 2 ) )
	{
		ConMsg ("ERROR: demo file protocol %i outdated, engine vnoteersion is %i \n", 
			m_DemoHeader.demoprotocol, DEMO_PROTOCOL );

		return NULL;
	}

	return &m_DemoHeader;
}

void CDemoFile::WriteFileBytes( FileHandle_t fh, int length )
{
	DemoFileDbg( "WriteFileBytes()\n" );
	int   copysize = length;
	char  copybuf[COM_COPY_CHUNK_SIZE];

	while ( copysize > COM_COPY_CHUNK_SIZE )
	{
		g_pFileSystem->Read ( copybuf, COM_COPY_CHUNK_SIZE, fh );
		m_pBuffer->Put( copybuf, COM_COPY_CHUNK_SIZE );
		copysize -= COM_COPY_CHUNK_SIZE;
	}

	g_pFileSystem->Read ( copybuf, copysize, fh );
	m_pBuffer->Put( copybuf, copysize );
	
	g_pFileSystem->Flush ( fh );
}

bool CDemoFile::Open(const char *name, bool bReadOnly, bool bMemoryBuffer, int nBufferSize/*=0*/, bool bAllowHeaderWrite/*=true*/)
{
	if ( m_pBuffer && m_pBuffer->IsValid() )
	{
		ConMsg ("CDemoFile::Open: file already open.\n");
		return false;
	}

	m_szFileName[0] = 0;  // clear name
	Q_memset( &m_DemoHeader, 0, sizeof(m_DemoHeader) ); // and demo header

	// This is used by replay, which manually writes a header.
	m_bAllowHeaderWrite = bAllowHeaderWrite;

	if ( bMemoryBuffer )
	{
		Assert( !bReadOnly );	// Only read from files
		Assert( nBufferSize > 0 );
		m_pBuffer = new CUtlBuffer( nBufferSize, nBufferSize, 0 );
		m_bIsStreamBuffer = false;
	}
	else
	{
		m_pBuffer = new CUtlStreamBuffer( name, NULL, bReadOnly ? CUtlBuffer::READ_ONLY : 0, false );
		m_bIsStreamBuffer = true;
	}

	// Demo files are always little endian
	m_pBuffer->SetBigEndian( false );

	if ( !m_pBuffer || !m_pBuffer->IsValid() )
	{
		ConMsg ("CDemoFile::Open: couldn't open file %s for %s.\n", 
			name, bReadOnly?"reading":"writing" );
		Close();
		return false;
	}

	if ( name )
	{
		Q_strncpy( m_szFileName, name, sizeof(m_szFileName) );
	}

	return true;
}

bool CDemoFile::IsOpen()
{
	return m_pBuffer && m_pBuffer->IsValid();
}

void CDemoFile::Close()
{
	// CUtlBuffer base class does NOT have a virtual destructor!
	if ( m_bIsStreamBuffer )
	{
		// Destructor will call Close() as needed
		delete static_cast<CUtlStreamBuffer*>(m_pBuffer);
	}
	else
	{
		delete m_pBuffer;
	}
	m_pBuffer = NULL;
}

int CDemoFile::GetSize()
{
	return m_pBuffer->TellMaxPut();
}

// Returns the PROTOCOL_VERSION used when .dem was recorded
int CDemoFile::GetProtocolVersion()
{
	return m_DemoHeader.networkprotocol;
}