First version of the SOurce SDK 2013

1 files changed, 1323 insertions, 0 deletions

diff --git a/mp/src/public/xzp.cpp b/mp/src/public/xzp.cpp
new file mode 100644
index 00000000..b192765e
--- /dev/null
+++ b/mp/src/public/xzp.cpp
@@ -0,0 +1,1323 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+//=============================================================================

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <ctype.h>

+#include <malloc.h>

+#ifdef _WIN32

+#include <process.h>

+#include <io.h>

+#endif

+#include <stddef.h>

+#include <fcntl.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include "tier1/utlbuffer.h"

+#include "tier1/strtools.h"

+#include "tier2/riff.h"

+

+#if defined( _WIN32 ) && !defined( _X360 )

+#include <windows.h>

+#endif

+

+#ifdef MAKE_GAMEDATA_TOOL

+	#include "../public/materialsystem/shader_vcs_version.h"

+	#include "../public/materialsystem/imaterial.h"

+	#include "../public/materialsystem/hardwareverts.h"

+	#include "../public/vtf/vtf.h"

+#else

+	#include "materialsystem/shader_vcs_version.h"

+	#include "materialsystem/imaterial.h"

+	#include "materialsystem/hardwareverts.h"

+#endif

+

+#include "xwvfile.h"

+#include "xzp.h"

+

+CByteswap g_xzpSwap;

+extern IFileReadBinary *g_pSndIO;

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+//-----------------------------------------------------------------------------

+// Datadesc blocks for byteswapping:

+//-----------------------------------------------------------------------------

+BEGIN_BYTESWAP_DATADESC( xZipHeader_t )

+	DEFINE_FIELD( Magic, FIELD_INTEGER ),

+	DEFINE_FIELD( Version, FIELD_INTEGER ),

+	DEFINE_FIELD( PreloadDirectoryEntries, FIELD_INTEGER ),

+	DEFINE_FIELD( DirectoryEntries, FIELD_INTEGER ),

+	DEFINE_FIELD( PreloadBytes, FIELD_INTEGER ),

+	DEFINE_FIELD( HeaderLength, FIELD_INTEGER ),

+	DEFINE_FIELD( FilenameEntries, FIELD_INTEGER ),

+	DEFINE_FIELD( FilenameStringsOffset, FIELD_INTEGER ),

+	DEFINE_FIELD( FilenameStringsLength, FIELD_INTEGER ),

+END_BYTESWAP_DATADESC()

+

+BEGIN_BYTESWAP_DATADESC( xZipDirectoryEntry_t )

+	DEFINE_FIELD( FilenameCRC, FIELD_INTEGER ),

+	DEFINE_FIELD( Length, FIELD_INTEGER ),

+	DEFINE_FIELD( StoredOffset, FIELD_INTEGER ),

+END_BYTESWAP_DATADESC()

+

+BEGIN_BYTESWAP_DATADESC( xZipFilenameEntry_t )

+	DEFINE_FIELD( FilenameCRC, FIELD_INTEGER ),

+	DEFINE_FIELD( FilenameOffset, FIELD_INTEGER ),

+	DEFINE_FIELD( TimeStamp, FIELD_INTEGER ),

+END_BYTESWAP_DATADESC()

+

+BEGIN_BYTESWAP_DATADESC( xZipFooter_t )

+	DEFINE_FIELD( Size, FIELD_INTEGER ),

+	DEFINE_FIELD( Magic, FIELD_INTEGER ),

+END_BYTESWAP_DATADESC()

+

+CXZip::CXZip()

+{

+	// Ensure that the header doesn't contain a valid magic yet.

+	m_Header.Magic = 0;	

+	m_pPreloadedData = NULL;

+	m_nPreloadStart = 0;

+	m_pDirectory = NULL;

+	m_pPreloadDirectory = NULL;

+	m_nRegular2PreloadEntryMapping = NULL;

+

+	m_bByteSwapped = false;

+

+	m_pFilenames = NULL;

+	m_hZip = NULL;

+	

+	m_pRead = NULL;

+	m_hUser = 0;

+	m_nMonitorLevel = 0;

+}

+

+CXZip::CXZip( const char* filename )

+{

+	// Ensure that the header doesn't contain a valid magic yet.

+	m_Header.Magic = 0;	

+	m_nPreloadStart = 0;

+	m_pPreloadedData = NULL;

+	m_pDirectory = NULL;

+	m_pPreloadDirectory = NULL;

+	m_nRegular2PreloadEntryMapping = NULL;

+

+	m_bByteSwapped = false;

+

+	m_pFilenames = NULL;

+	m_hZip = NULL;

+

+	m_pRead = NULL;

+	m_hUser = 0;

+	m_nMonitorLevel = 0;

+

+	Load( filename );

+}

+

+CXZip::CXZip( FILE* handle, int offset, int size )	// file handle and offset of the zip file

+{

+	m_pRead = NULL;

+	m_hUser = 0;

+	m_nPreloadStart = 0;

+	m_pDirectory = NULL;

+	m_pPreloadDirectory = NULL;

+	m_nRegular2PreloadEntryMapping = NULL;

+

+	m_bByteSwapped = false;

+

+	m_pFilenames = NULL;

+	m_pPreloadedData = NULL;

+	m_nMonitorLevel = 0;

+

+	Load( handle, offset, size );

+}

+

+CXZip::~CXZip()

+{

+	Unload();

+}

+

+bool CXZip::InstallAlternateIO( int (*read)( void* buffer, int offset, int length, int nDestLength, int hUser), int hUser )

+{

+	m_pRead = read;

+	m_hUser = hUser;

+	return true;

+}

+

+

+// Loads an xZip file into memory:

+bool CXZip::Load( const char* filename, bool bPreload )

+{

+	FILE* hZip = fopen( filename, "rb" );

+	fseek(hZip,0,SEEK_END);

+	int nSize = ftell( hZip );

+	return Load( hZip, 0, nSize, bPreload );

+}

+

+bool CXZip::Load( FILE* handle, int nOffset, int nSize, bool bPreload )	// Load a pack file into this instance.  Returns true on success.

+{

+	Unload();

+

+	m_bByteSwapped = false;

+

+	m_hZip = handle;

+	m_nOffset = nOffset;

+	m_nSize = nSize;

+

+	// Hacky, clean up:

+	if( m_hZip && !m_pRead )

+	{

+		InstallAlternateIO( defaultRead, (int)m_hZip );

+	}

+

+	if( m_hZip == NULL && m_pRead == NULL )

+	{

+		return false;

+	}

+

+	// Read the header:

+	m_pRead( &m_Header, 0, -1, sizeof(m_Header), m_hUser );

+

+	// Validate the Magic number and at the same time determine if I am reading a regular or swappped xZip file:

+	switch( m_Swap.SourceIsNativeEndian<int>( m_Header.Magic, xZipHeader_t::MAGIC ) )

+	{

+		// Does the magic match exactly?

+		case 1:

+			m_Swap.ActivateByteSwapping( false );

+			m_bByteSwapped = false;

+			break;

+

+		// Does the magic match, but is swapped?

+		case 0:

+			m_bByteSwapped = true;

+			m_Swap.ActivateByteSwapping( true );	// We must be reading the opposite endianness.

+			m_Swap.SwapFieldsToTargetEndian<xZipHeader_t>( &m_Header );

+			break;

+

+		default: 

+			assert( 0 );

+			// Fail gently in release:

+		

+		// The magic doesn't match in any respect:

+		case -1:

+			{

+				printf("Invalid xZip file\n");

+

+				if( m_hZip )

+				{

+					fclose( m_hZip );

+					m_hZip = NULL;

+				}

+				return false;

+			}

+	}

+

+	// Validate the archive version:

+	if( m_Header.Version != xZipHeader_t::VERSION )

+	{

+		// Backward compatable support for version 1

+		Msg("Incorrect xZip version found %u - expected %u\n", m_Header.Version, xZipHeader_t::VERSION );

+		if( m_hZip )

+		{

+			fclose( m_hZip );

+			m_hZip = NULL;

+		}

+

+		m_Header.Magic = xZipHeader_t::FREE;

+		return false;

+	}

+

+	// Read the directory:

+	{

+		MEM_ALLOC_CREDIT();

+

+		m_pDirectory = (xZipDirectoryEntry_t*)malloc( sizeof(xZipDirectoryEntry_t) * m_Header.DirectoryEntries );

+		m_pRead( m_pDirectory, m_Header.HeaderLength, -1, sizeof( xZipDirectoryEntry_t ) * m_Header.DirectoryEntries, m_hUser );

+

+		// Swap the directory entries if nessecary

+		if( m_bByteSwapped )

+		{

+			for( unsigned nDirectoryEntry = 0; nDirectoryEntry < m_Header.DirectoryEntries; nDirectoryEntry++ )

+			{

+				m_Swap.SwapFieldsToTargetEndian<xZipDirectoryEntry_t>(  &( m_pDirectory[nDirectoryEntry] ) );

+			}

+		}

+

+

+		m_nPreloadStart = m_Header.HeaderLength + ( sizeof( xZipDirectoryEntry_t ) * m_Header.DirectoryEntries );

+	}

+

+	// Preload the preload chunk if desired:

+	if( bPreload )

+	{

+		PreloadData();

+	}

+

+	return true;

+}

+

+void CXZip::Unload()

+{

+	DiscardPreloadedData();

+

+	// Dump the directory:

+	if( m_pDirectory )

+	{

+		free( m_pDirectory );

+		m_pDirectory = NULL;

+	}

+

+	if( m_pFilenames )

+	{

+		free( m_pFilenames );

+		m_pFilenames = NULL;

+	}

+

+	// Invalidate the header:

+	m_Header.Magic = 0;

+

+	if( m_hZip )

+	{

+		fclose( m_hZip );

+		m_hZip = NULL;

+	}

+

+}

+

+//-----------------------------------------------------------------------------

+// CXZip::PreloadData

+//

+// Loads the preloaded data if it isn't already.

+//-----------------------------------------------------------------------------

+

+void CXZip::PreloadData()

+{

+	Assert( IsValid() );

+

+	// Ensure it isn't already preloaded

+	if( m_pPreloadedData )

+		return;

+

+	// If I don't have a preloaded section, ignore the request.

+	if( !m_Header.PreloadBytes || !m_Header.PreloadDirectoryEntries )

+		return;

+

+	// Allocate and read the data block in:

+#ifndef _X360

+	MEM_ALLOC_CREDIT_( "xZip" );

+	m_pPreloadedData = malloc( m_Header.PreloadBytes );

+

+	// Just drop out if allocation fails;

+	if ( !m_pPreloadedData )

+		return;

+

+	m_pRead( m_pPreloadedData, m_nPreloadStart, -1, m_Header.PreloadBytes, m_hUser );

+#else

+	int nAlignedStart = AlignValue( ( m_nPreloadStart - XBOX_HDD_SECTORSIZE ) + 1, XBOX_HDD_SECTORSIZE );

+	int nBytesToRead = AlignValue( ( m_nPreloadStart - nAlignedStart ) + m_Header.PreloadBytes, XBOX_HDD_SECTORSIZE );

+	int nBytesBuffer = AlignValue( nBytesToRead, XBOX_HDD_SECTORSIZE );

+	byte *pReadData = (byte *)malloc( nBytesBuffer );

+	

+	// Just drop out if allocation fails;

+	if ( !pReadData )

+		return; 

+	

+	MEM_ALLOC_CREDIT_( "xZip" );

+	m_pRead( pReadData, nAlignedStart, nBytesBuffer,nBytesToRead, m_hUser );

+	m_pPreloadedData = pReadData + ( m_nPreloadStart - nAlignedStart );

+#endif

+

+	// Set up the preload directory:

+	m_pPreloadDirectory = (xZipDirectoryEntry_t*)m_pPreloadedData;

+

+	// Swap the preload directory:

+	if ( m_bByteSwapped )

+	{

+		for ( unsigned nDirectoryEntry = 0; nDirectoryEntry < m_Header.PreloadDirectoryEntries; nDirectoryEntry++ )

+		{

+			m_Swap.SwapFieldsToTargetEndian<xZipDirectoryEntry_t>( &( m_pPreloadDirectory[nDirectoryEntry] ) );

+		}

+	}

+

+	// Set up the regular 2 preload mapping section:

+	m_nRegular2PreloadEntryMapping = (unsigned short*)(((unsigned char*)m_pPreloadDirectory) + ( sizeof(xZipDirectoryEntry_t) * m_Header.PreloadDirectoryEntries ));

+

+	// Swap the regular to preload mapping

+	if ( m_bByteSwapped )

+	{

+		m_Swap.SwapBufferToTargetEndian<short>( (short *)m_nRegular2PreloadEntryMapping,  (short *)m_nRegular2PreloadEntryMapping, m_Header.DirectoryEntries );

+	}

+

+}

+

+//-----------------------------------------------------------------------------

+// CXZip::DiscardPreloadedData

+//

+// frees the preloaded data cache if it's present.

+//-----------------------------------------------------------------------------

+

+void CXZip::DiscardPreloadedData()

+{

+	if ( m_pPreloadedData )

+	{

+#ifndef _X360

+		free( m_pPreloadedData );

+#else

+		int nAlignedStart = AlignValue( ( m_nPreloadStart - XBOX_HDD_SECTORSIZE ) + 1, XBOX_HDD_SECTORSIZE );

+		byte *pReadData = (byte *)m_pPreloadedData - ( m_nPreloadStart - nAlignedStart );

+		free( pReadData );

+#endif

+		m_pPreloadedData = NULL;

+		m_pPreloadDirectory = NULL;

+		m_nRegular2PreloadEntryMapping = NULL;

+	}

+}

+

+int CXZip::defaultRead( void* buffer, int offset, int destLength, int length, int hUser)

+{

+	fseek( (FILE*)hUser, offset, SEEK_SET );

+	return fread( buffer, 1, length, (FILE*)hUser );

+}

+

+char* CXZip::GetEntryFileName( unsigned CRC, char* pDefault )

+{

+	Assert( IsValid() );

+

+	if( IsRetail() )

+	{

+		return pDefault;

+	}

+	else

+	{

+

+		// Make sure I have a filename section:

+		if( m_Header.FilenameStringsOffset == 0 || m_Header.FilenameEntries == 0 || CRC == 0 )

+		{

+			return pDefault;

+		}

+

+		// If the filename chunk isn't here, load it up:

+		if( !m_pFilenames )

+		{

+			MEM_ALLOC_CREDIT_("xZip");

+			m_pFilenames = (xZipFilenameEntry_t*)malloc( m_Header.FilenameStringsLength );

+			m_pRead( m_pFilenames, m_Header.FilenameStringsOffset, -1, m_Header.FilenameStringsLength, m_hUser );

+

+			// TODO: Swap!

+			for( unsigned int i=0; i< m_Header.FilenameEntries;i++ )

+			{

+				m_Swap.SwapFieldsToTargetEndian<xZipFilenameEntry_t>(&m_pFilenames[i]);

+			}

+		}

+

+		// Find this entry in the preload directory

+		xZipFilenameEntry_t entry;

+		entry.FilenameCRC = CRC;

+

+		xZipFilenameEntry_t* found = (xZipFilenameEntry_t*)bsearch( &entry, m_pFilenames, m_Header.FilenameEntries, sizeof(xZipFilenameEntry_t), xZipFilenameEntry_t::xZipFilenameEntryCompare );

+

+		if( !found ) 

+			return pDefault;

+

+		return (((char*)m_pFilenames) + found->FilenameOffset) - m_Header.FilenameStringsOffset; 	

+	}

+}

+

+// Sanity checks that the zip file is ready and readable:

+bool CXZip::IsValid()

+{

+	if( m_Header.Magic != xZipHeader_t::MAGIC )

+		return false;

+

+	if( m_Header.Version > xZipHeader_t::VERSION )

+		return false;

+

+	if( !m_pDirectory )

+		return false;

+

+	return true;

+}

+

+void CXZip::WarningDir()

+{

+	Assert( IsValid());

+	

+	for( unsigned i = 0; i< m_Header.DirectoryEntries; i++ )

+	{

+		Msg( GetEntryFileName( m_pDirectory[i].FilenameCRC ) );

+	}

+}

+

+

+int CXZip::ReadIndex( int nEntryIndex, int nFileOffset, int nDestBytes, int nLength, void* pBuffer )

+{

+	Assert( IsValid() );

+

+	if( nLength <=0 || nEntryIndex < 0 ) 

+		return 0;

+

+	// HACK HACK HACK - convert the pack file index to a local file index (ie, assuming the full file index is being passed in)

+	nFileOffset -= m_pDirectory[nEntryIndex].StoredOffset;

+	// HACK HACK HACK

+

+	// If I've got my preload section loaded, first check there:

+	xZipDirectoryEntry_t* pPreloadEntry = GetPreloadEntry(nEntryIndex);

+

+	if( pPreloadEntry )

+	{

+		Assert( pPreloadEntry->FilenameCRC == m_pDirectory[nEntryIndex].FilenameCRC );

+

+		if( nFileOffset + nLength <= (int)pPreloadEntry->Length )

+		{

+			if( m_nMonitorLevel >= 2 )

+			{

+				char* filename = GetEntryFileName( m_pDirectory[nEntryIndex].FilenameCRC, "(!!! unknown !!!)" );

+

+				Msg("PACK(preload) %s: length:%i offset:%i",filename,nLength, nFileOffset);

+

+			}

+

+			memcpy( pBuffer, (char*)m_pPreloadedData + pPreloadEntry->StoredOffset + nFileOffset - m_nPreloadStart, nLength );

+			return nLength;

+		}

+	}

+

+	// Offset int the zip to start the read:

+	int ZipOffset = m_pDirectory[nEntryIndex].StoredOffset + nFileOffset;

+	int nBytesRead = m_pRead( pBuffer, ZipOffset, nDestBytes, nLength, m_hUser);

+

+	if( m_nMonitorLevel )

+	{

+		char* filename = GetEntryFileName( m_pDirectory[nEntryIndex].FilenameCRC, "(!!! unknown !!!)" );

+

+		unsigned preload = 0;

+		if( m_pPreloadedData && m_nRegular2PreloadEntryMapping[nEntryIndex] != 0xFFFF )

+		{

+			// Find this entry in the preload directory

+			xZipDirectoryEntry_t* entry = &(m_pPreloadDirectory[m_nRegular2PreloadEntryMapping[nEntryIndex]]);

+			Assert(entry->FilenameCRC == m_pDirectory[nEntryIndex].FilenameCRC);

+

+			preload = entry->Length;

+		}

+

+		Msg("PACK %s: length:%i offset:%i (preload bytes:%i)",filename,nLength, nFileOffset, preload);

+	}

+	

+	return nBytesRead;

+}

+

+bool CXZip::GetSimpleFileOffsetLength( const char* FileName, int& nBaseIndex, int &nFileOffset, int &nLength )

+{

+	Assert( IsValid() );

+

+	xZipDirectoryEntry_t entry;

+	entry.FilenameCRC = xZipCRCFilename( FileName );

+

+	xZipDirectoryEntry_t* found = (xZipDirectoryEntry_t*)bsearch( &entry, m_pDirectory, m_Header.DirectoryEntries, sizeof(xZipDirectoryEntry_t), xZipDirectoryEntry_t::xZipDirectoryEntryFindCompare );

+

+	if( found == NULL )

+		return false;

+

+	nFileOffset = found[0].StoredOffset;

+	nLength = found[0].Length;

+	nBaseIndex = (((int)((char*)found - (char*)m_pDirectory))/sizeof(xZipDirectoryEntry_t));

+

+	return true;

+}

+

+bool CXZip::ExtractFile( const char* FileName )

+{

+	return false;

+}

+

+// Compares to xZipDirectoryEntries.

+//

+// Sorts in the following order:  

+//		FilenameCRC

+//		FileOffset

+//		Length

+//		StoredOffset

+//

+// The sort function may look overly complex, but it is actually useful for locating different pieces of 

+// the same file in a meaningful order.

+//

+int __cdecl xZipDirectoryEntry_t::xZipDirectoryEntrySortCompare( const void* left, const void* right )

+{

+	xZipDirectoryEntry_t *l = (xZipDirectoryEntry_t*)left,

+					     *r = (xZipDirectoryEntry_t*)right;

+

+	if( l->FilenameCRC < r->FilenameCRC )

+	{

+		return -1;

+	}

+

+	else if( l->FilenameCRC > r->FilenameCRC )

+	{

+		return 1;

+	}

+

+	// else l->FileOffset == r->FileOffset

+	if( l->Length < r->Length )

+	{

+		return -1;

+	}

+	else if( l->Length > r->Length )

+	{

+		return 1;

+	}

+

+	// else l->Length == r->Length

+	if( l->StoredOffset < r->StoredOffset )

+	{

+		return -1;

+	}

+	else if( l->StoredOffset > r->StoredOffset )

+	{

+		return 1;

+	}

+

+	// else everything is identical:

+	return 0;

+

+}

+

+// Find an entry with matching CRC only

+int __cdecl xZipDirectoryEntry_t::xZipDirectoryEntryFindCompare( const void* left, const void* right )

+{

+	xZipDirectoryEntry_t *l = (xZipDirectoryEntry_t*)left,

+					     *r = (xZipDirectoryEntry_t*)right;

+

+	if( l->FilenameCRC < r->FilenameCRC )

+	{

+		return -1;

+	}

+

+	else if( l->FilenameCRC > r->FilenameCRC )

+	{

+		return 1;

+	}

+

+	return 0;

+

+}

+

+int __cdecl xZipFilenameEntry_t::xZipFilenameEntryCompare( const void* left, const void* right )

+{

+	xZipFilenameEntry_t *l = (xZipFilenameEntry_t*)left,

+					    *r = (xZipFilenameEntry_t*)right;

+

+	if( l->FilenameCRC < r->FilenameCRC )

+	{

+		return -1;

+	}

+

+	else if( l->FilenameCRC > r->FilenameCRC )

+	{

+		return 1;

+	}

+

+	return 0;

+

+}

+

+

+// CRC's an individual xZip filename:

+unsigned xZipCRCFilename( const char* filename )

+{

+	unsigned hash = 0xAAAAAAAA;	// Alternating 1's and 0's

+

+	for( ; *filename ; filename++ )

+	{

+		char c = *filename;

+	

+		// Fix slashes

+		if( c == '/' )

+			c = '\\';

+		else

+			c = (char)tolower(c);

+

+		hash = hash * 33 + c;

+	}

+

+	return hash;

+}

+

+#if defined( MAKE_GAMEDATA_TOOL )

+

+// ------------

+xZipHeader_t Header;

+xZipDirectoryEntry_t	 *pDirectoryEntries = NULL;

+xZipDirectoryEntry_t	 *pPreloadDirectoryEntries = NULL;

+xZipFilenameEntry_t		 *pFilenameEntries = NULL;

+char					 *pFilenameData = NULL;

+unsigned				  nFilenameDataLength = 0;

+

+unsigned			     InputFileBytes = 0;

+

+char* CleanFilename( char* filename )

+{

+	// Trim leading white space:

+	while( isspace(*filename) )

+		filename++;

+

+	// Trim trailing white space:

+	while( isspace( filename[strlen(filename)-1] ) )

+	{

+		filename[strlen(filename)-1] = '\0';

+	}

+

+	return filename;

+}

+

+

+bool CopyFileBytes( FILE* hDestination, FILE* hSource, unsigned nBytes )

+{

+	char buffer[16384];

+

+	while( nBytes > 0 )

+	{

+		int nBytesRead = fread( buffer, 1, nBytes > sizeof(buffer) ? sizeof(buffer) : nBytes,  hSource );

+		fwrite(buffer, 1, nBytesRead,  hDestination );

+		nBytes -= nBytesRead;

+	}

+

+	return true;

+}

+

+bool WriteFileBytes( FILE* hDestination, CUtlBuffer &source, unsigned nBytes )

+{

+	unsigned int nBytesWritten = fwrite(source.Base(), 1, nBytes,  hDestination );

+	return (nBytesWritten == nBytes);

+}

+

+void PadFileBytes(FILE* hFile, int nPreloadPadding )

+{

+	if( nPreloadPadding < 0 || nPreloadPadding >= 512)

+	{

+		puts("Invalid padding");

+		return;

+	}

+	

+	char padding[512];

+	memset(padding,0,nPreloadPadding);

+	fwrite(padding,1,nPreloadPadding,hFile);

+}

+

+void AddFilename( const char* filename )

+{

+	unsigned CRCfilename = xZipCRCFilename( filename );

+

+	// If we already have this filename don't add it again:

+	for( int i = 0; i < (int)Header.FilenameEntries; i++ )

+	{

+		if( pFilenameEntries[i].FilenameCRC == CRCfilename )

+		{

+			return;

+		}

+	}

+

+	Header.FilenameEntries++;

+	

+	// Add the file to the file string table:

+	pFilenameEntries = (xZipFilenameEntry_t*)realloc( pFilenameEntries, sizeof(xZipFilenameEntry_t) * Header.FilenameEntries );

+	

+	int filenameLength = (int)strlen(filename) + 1;

+	pFilenameEntries[Header.FilenameEntries-1].FilenameCRC = CRCfilename;

+	pFilenameEntries[Header.FilenameEntries-1].FilenameOffset = nFilenameDataLength;

+

+	// Grab the timestamp for the file:

+	struct stat buf;

+	if( stat( filename, &buf ) != -1 )

+	{

+		pFilenameEntries[Header.FilenameEntries - 1].TimeStamp = buf.st_mtime;

+	}

+	else

+	{

+		pFilenameEntries[Header.FilenameEntries - 1].TimeStamp = 0;

+	}

+

+	nFilenameDataLength += filenameLength;

+	pFilenameData = (char*)realloc(pFilenameData, nFilenameDataLength);

+	memcpy(pFilenameData + nFilenameDataLength - filenameLength, filename, filenameLength);

+}

+

+FILE* hTempFilePreload;

+FILE* hTempFileData;

+FILE* hOutputFile;

+

+bool xZipAddFile( const char* filename, CUtlBuffer &fileBuff, bool bPrecacheEntireFile, bool bProcessPrecacheHeader, bool bProcessPrecacheHeaderOnly )

+{

+	unsigned int fileSize = fileBuff.TellMaxPut();

+

+	// Track total input bytes for stats reasons

+	InputFileBytes += fileSize;

+

+	unsigned customPreloadSize = 0;

+	

+	if( bPrecacheEntireFile  )

+	{

+		customPreloadSize = fileSize;

+	} 

+	else if( bProcessPrecacheHeader )

+	{

+		customPreloadSize = xZipComputeCustomPreloads( filename );

+	}

+	else if( bProcessPrecacheHeaderOnly )

+	{

+		customPreloadSize = xZipComputeCustomPreloads( filename );

+		fileSize = min( fileSize, customPreloadSize );

+	}

+

+	unsigned CRC = xZipCRCFilename( filename );

+

+	// Does this file have a split header?

+	if( customPreloadSize > 0  ) 

+	{

+		// Initialize the entry header:

+		xZipDirectoryEntry_t entry;

+		memset( &entry, 0, sizeof( entry ) );

+		

+		entry.FilenameCRC = CRC;

+		entry.Length = customPreloadSize;

+		entry.StoredOffset = ftell(hTempFilePreload);

+

+		// Add the directory entry to the preload table:

+		Header.PreloadDirectoryEntries++;

+		pPreloadDirectoryEntries = (xZipDirectoryEntry_t*)realloc( pPreloadDirectoryEntries, sizeof( xZipDirectoryEntry_t ) * Header.PreloadDirectoryEntries );

+		memcpy( pPreloadDirectoryEntries + Header.PreloadDirectoryEntries - 1, &entry, sizeof( entry ) );

+

+		// Concatenate the data in the preload file:

+		fileBuff.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );

+		WriteFileBytes( hTempFilePreload, fileBuff, entry.Length );

+		fileBuff.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );

+

+		

+		// Add the filename entry:

+		AddFilename( filename );

+

+		// Spew it:

+		printf("+Preload: \"%s\": Length:%u\n", filename, entry.Length );

+	}

+

+	// Copy the file to the regular data region:

+	xZipDirectoryEntry_t entry;

+	memset(&entry,0,sizeof(entry));

+	entry.FilenameCRC = CRC;

+	entry.Length = fileSize;

+	entry.StoredOffset = ftell(hTempFileData);		

+

+	// Add the directory entry to the table:

+	Header.DirectoryEntries++;

+	pDirectoryEntries = (xZipDirectoryEntry_t*)realloc( pDirectoryEntries, sizeof( xZipDirectoryEntry_t ) * Header.DirectoryEntries );

+	memcpy( pDirectoryEntries + Header.DirectoryEntries - 1, &entry, sizeof( entry ) );

+

+	WriteFileBytes( hTempFileData, fileBuff, entry.Length );

+

+	// Align the data region to a 512 byte boundry:  (has to be on last entry as well to ensure enough space to perform the final read,

+	// and initial alignment is taken careof by assembexzip)

+	int nPadding = ( XBOX_HDD_SECTORSIZE - ( ftell( hTempFileData ) % XBOX_HDD_SECTORSIZE) ) % XBOX_HDD_SECTORSIZE;

+

+	PadFileBytes( hTempFileData, nPadding );

+

+	// Add the file to the file string table:

+	AddFilename( filename );

+

+	// Print a summary

+	printf("+File: \"%s\": Length:%u Padding:%i\n", filename,  entry.Length, nPadding );

+

+	return true;

+}

+

+bool xZipAddFile( const char* zipname, bool bPrecacheEntireFile, bool bProcessPrecacheHeader, bool bProcessPrecacheHeaderOnly )

+{

+	// Clean up the filename:

+	char buffer[MAX_PATH];

+	strcpy(buffer, zipname);

+

+	// Fix slashes and convert it to lower case:

+	char *filename;

+	for( filename = buffer; *filename; filename++ )

+	{

+		if( *filename == '/' )

+			*filename = '\\';

+		else

+		{

+			*filename = (char)tolower(*filename);

+		}

+	}

+

+	// Skip leading white space:

+	for( filename = buffer; isspace(*filename); filename++ )

+		;

+

+	// Obliterate trailing white space:

+	for(;;)

+	{

+		int len = (int)strlen( filename );

+		if( len <= 0 )

+		{

+			printf("!!!! BAD FILENAME: \"%s\"\n", filename );

+			return false;

+		}

+		

+		if( isspace( filename[len-1] ) )

+			filename[len-1]='\0';

+		else

+			break;

+	}

+

+	// Ensure we don't already have this file:

+	unsigned CRC = xZipCRCFilename( filename );

+

+	for( unsigned i=0; i < Header.DirectoryEntries; i++ )

+	{

+		if( pDirectoryEntries[i].FilenameCRC == CRC )

+		{

+			printf("!!!! NOT ADDING DUPLICATE FILENAME: \"%s\"\n", filename );

+			return false;

+		}

+	}

+

+	// Attempt to open the file:

+	FILE* hFile = fopen( filename, "rb" );

+	if( !hFile )

+	{

+		printf("!!!! FAILED TO OPEN FILE: \"%s\"\n", filename );

+		return false;

+	}

+

+	// Get the length of the file:

+	fseek(hFile,0,SEEK_END);

+	unsigned fileSize = ftell(hFile);

+	fseek(hFile,0,SEEK_SET);

+

+	CUtlBuffer fileBuff;

+	fileBuff.EnsureCapacity( fileSize );

+	fread( fileBuff.Base(), fileSize, 1, hFile );

+	fclose( hFile );

+

+	fileBuff.SeekPut( CUtlBuffer::SEEK_HEAD, fileSize );

+

+	return xZipAddFile( zipname, fileBuff, bPrecacheEntireFile, bProcessPrecacheHeader, bProcessPrecacheHeaderOnly );

+}

+

+int xZipBegin( const char* fileNameXzip )

+{

+	// Create and initialize the header:

+	memset( &Header, 0, sizeof(Header) );	// Zero out the header:

+	Header.Magic = xZipHeader_t::MAGIC;

+	Header.Version = xZipHeader_t::VERSION;

+	Header.HeaderLength = sizeof(Header);

+

+	// Open the output file:

+	hOutputFile = fopen(fileNameXzip,"wb+");

+	if( !hOutputFile )

+	{

+		printf("Failed to open \"%s\" for writing.\n", fileNameXzip);

+		exit( EXIT_FAILURE);

+	}

+	

+	// Create a temporary file for storing the preloaded data:

+	hTempFilePreload = tmpfile();

+	if( !hTempFilePreload )

+	{

+		printf( "Error: failed to create temporary file\n" );

+		return EXIT_FAILURE;

+	}

+

+	// Create a temporary file for storing the non preloaded data

+	hTempFileData = tmpfile();

+	if( !hTempFileData )

+	{

+		printf( "Error: failed to create temporary file\n");

+		return EXIT_FAILURE;

+	}

+	

+	return EXIT_SUCCESS;

+}

+

+bool xZipEnd()

+{

+	int nPreloadDirectorySize = sizeof(xZipDirectoryEntry_t)*Header.PreloadDirectoryEntries;

+	int nRegular2PreloadSize = sizeof(unsigned short) * Header.DirectoryEntries;

+

+	// Compute the size of the preloaded section:

+	if( Header.PreloadDirectoryEntries )

+	{

+		fseek( hTempFilePreload, 0, SEEK_END );

+		Header.PreloadBytes = ftell(hTempFilePreload) + nPreloadDirectorySize + nRegular2PreloadSize;	// Raw# of bytes to preload

+		fseek( hTempFilePreload, 0, SEEK_SET );

+	}

+	else

+	{

+		Header.PreloadBytes = 0;

+	}

+

+	// Number of bytes preceeding the preloaded section:

+	int nPreloadOffset = sizeof( Header ) + ( sizeof( xZipDirectoryEntry_t ) * Header.DirectoryEntries );

+

+	// Number of bytes to pad between the end of the preload section and the start of the data section:

+	int nPadding = ( 512 - ( ( nPreloadOffset + Header.PreloadBytes ) % 512) ) %512;				// Number of alignment bytes after the preload section

+

+	// Offset past the preload section:

+	int nDataOffset = nPreloadOffset + Header.PreloadBytes + nPadding;

+

+	// Write out the header: (will need to be rewritten at the end as well) - note: not even bothering to byteswap at this point

+	fwrite(&Header,sizeof(Header),1,hOutputFile);

+

+

+	// Fixup each of the directory entries to make them relative to the beginning of the file.

+	for( unsigned i=0; i< Header.DirectoryEntries;i++ )

+	{

+		xZipDirectoryEntry_t* pDir = &(pDirectoryEntries[i]);

+

+		// Adjust files in the regular data area:

+		pDir->StoredOffset = nDataOffset + pDir->StoredOffset;

+	}

+

+	// Sort and write the directory:

+	printf("Sorting and writing %i directory entries...\n",Header.DirectoryEntries);

+	qsort(pDirectoryEntries,Header.DirectoryEntries,sizeof(xZipDirectoryEntry_t),&xZipDirectoryEntry_t::xZipDirectoryEntrySortCompare); 

+

+	// Swap the directory entries:

+	for( unsigned i=0; i < Header.DirectoryEntries; i++ )

+	{

+		g_xzpSwap.SwapFieldsToTargetEndian<xZipDirectoryEntry_t>(&pDirectoryEntries[i]);

+	}

+

+	fwrite(pDirectoryEntries,Header.DirectoryEntries*sizeof(xZipDirectoryEntry_t),1, hOutputFile);

+

+	// Swap the directory back for later use:

+	for( unsigned i=0; i < Header.DirectoryEntries; i++ )

+	{

+		g_xzpSwap.SwapFieldsToTargetEndian<xZipDirectoryEntry_t>(&pDirectoryEntries[i]);

+	}

+

+	// Copy the preload section:

+	if( Header.PreloadBytes > 0 )

+	{

+		printf("Generating the preload section...(%u)\n", Header.PreloadBytes);

+

+

+		// Fixup each of the directory entries to make them relative to the beginning of the file.

+		for( unsigned i=0; i< Header.PreloadDirectoryEntries;i++ )

+		{

+			xZipDirectoryEntry_t* pDir = &(pPreloadDirectoryEntries[i]);

+

+			// Shift preload data down by preload bytes (and skipping over the directory):

+			pDir->StoredOffset += nPreloadOffset + nPreloadDirectorySize + nRegular2PreloadSize;

+		}

+

+		printf("Sorting %u preload directory entries...\n",Header.PreloadDirectoryEntries);

+		qsort(pPreloadDirectoryEntries,Header.PreloadDirectoryEntries,sizeof(xZipDirectoryEntry_t),&xZipDirectoryEntry_t::xZipDirectoryEntrySortCompare); 

+

+		printf("Building regular to preload mapping table for %u entries...\n", Header.DirectoryEntries );

+		unsigned short* Regular2Preload = (unsigned short*)malloc( nRegular2PreloadSize );

+		for( unsigned i = 0; i < Header.DirectoryEntries; i++ )

+		{

+			unsigned short j;

+			for( j = 0; j < Header.PreloadDirectoryEntries; j++ )

+			{

+				if( pDirectoryEntries[i].FilenameCRC == pPreloadDirectoryEntries[j].FilenameCRC )

+					break;

+			}

+

+			// If I couldn't find it mark it as non-existant:

+			if( j == Header.PreloadDirectoryEntries )

+				j = 0xFFFF;

+

+			Regular2Preload[i] = j;

+		}

+

+		printf("Writing preloaded directory entreis...\n" );

+

+		// Swap the preload directory entries:

+		for( unsigned i=0; i < Header.PreloadDirectoryEntries; i++ )

+		{

+			g_xzpSwap.SwapFieldsToTargetEndian<xZipDirectoryEntry_t>(&pPreloadDirectoryEntries[i]);

+		}

+

+		fwrite( pPreloadDirectoryEntries, Header.PreloadDirectoryEntries*sizeof(xZipDirectoryEntry_t),1, hOutputFile );

+

+		// Swap them back:

+		for( unsigned i=0; i < Header.PreloadDirectoryEntries; i++ )

+		{

+			g_xzpSwap.SwapFieldsToTargetEndian<xZipDirectoryEntry_t>(&pPreloadDirectoryEntries[i]);

+		}

+

+		printf("Writing regular to preload mapping (%u bytes)...\n", sizeof(unsigned short)*Header.DirectoryEntries );

+		

+		// Swap regular to preload mapping:

+		g_xzpSwap.SwapBufferToTargetEndian<short>((short*)Regular2Preload, (short*)Regular2Preload, nRegular2PreloadSize / sizeof(short) );

+

+		fwrite( Regular2Preload, nRegular2PreloadSize,1,hOutputFile );

+

+		// Swap it back

+		g_xzpSwap.SwapBufferToTargetEndian<short>((short*)Regular2Preload, (short*)Regular2Preload, nRegular2PreloadSize / sizeof(short) );

+

+		printf("Copying %u Preloadable Bytes...\n", Header.PreloadBytes - nPreloadDirectorySize - nRegular2PreloadSize );

+		fseek(hTempFilePreload,0,SEEK_SET);

+		CopyFileBytes(hOutputFile, hTempFilePreload, Header.PreloadBytes - nPreloadDirectorySize - nRegular2PreloadSize  );

+	}

+

+	// Align the data section following the preload section:

+	if( nPadding )

+	{

+		printf("Aligning Data Section Start by %u bytes...\n", nPadding );

+		PadFileBytes(hOutputFile, nPadding );

+	}

+

+	// Copy the data section:

+	fseek(hTempFileData, 0, SEEK_END );

+	unsigned length = ftell( hTempFileData );

+	fseek(hTempFileData, 0, SEEK_SET );

+	printf("Copying %u Bytes...\n",length);

+

+	CopyFileBytes(hOutputFile, hTempFileData, length);

+

+	// Write out the filename data if present:

+	if( nFilenameDataLength && Header.FilenameEntries )

+	{

+		Header.FilenameStringsOffset = ftell(hOutputFile);

+		Header.FilenameStringsLength = (Header.FilenameEntries*sizeof(xZipFilenameEntry_t)) + nFilenameDataLength;

+		

+		// Adjust the offset in each of the filename offsets to absolute position in the file.

+		for( unsigned i=0;i<Header.FilenameEntries;i++ )

+		{

+			pFilenameEntries[i].FilenameOffset += ( Header.FilenameStringsOffset + (Header.DirectoryEntries*sizeof(xZipFilenameEntry_t)));

+		}

+

+		printf("Sorting and writing %u filename directory entries...\n",Header.FilenameEntries);

+

+		// Sort the data:

+		qsort(pFilenameEntries,Header.FilenameEntries,sizeof(xZipFilenameEntry_t),&xZipFilenameEntry_t::xZipFilenameEntryCompare); 

+

+		// Write the data out:

+		for( unsigned int i = 0; i < Header.FilenameEntries; i++ )

+		{

+			g_xzpSwap.SwapFieldsToTargetEndian<xZipFilenameEntry_t>(&pFilenameEntries[i]);

+		}

+

+		fwrite(pFilenameEntries,1,Header.FilenameEntries*sizeof(xZipFilenameEntry_t),hOutputFile);

+

+		// Swap them back:

+		for( unsigned int i = 0; i < Header.FilenameEntries; i++ )

+		{

+			g_xzpSwap.SwapFieldsToTargetEndian<xZipFilenameEntry_t>(&pFilenameEntries[i]);

+		}

+

+		printf("Writing %u bytes of filename data...\n",nFilenameDataLength);

+		fwrite(pFilenameData,1,nFilenameDataLength,hOutputFile);

+	}

+

+	// Compute the total file size, including the size of the footer:

+	unsigned OutputFileBytes = ftell(hOutputFile) + sizeof(xZipFooter_t);

+

+	// Write the footer:  (block used to keep possibly swapped footer from being used later)

+	{

+		xZipFooter_t footer;

+		footer.Magic = xZipFooter_t::MAGIC;

+		footer.Size = OutputFileBytes;

+

+		g_xzpSwap.SwapFieldsToTargetEndian<xZipFooter_t>( &footer );	// Swap the footer

+		fwrite( &footer, 1, sizeof(footer), hOutputFile );

+	}

+

+	// Seek back and rewrite the header (filename data changes it for example)

+	fseek(hOutputFile,0,SEEK_SET);

+	g_xzpSwap.SwapFieldsToTargetEndian<xZipHeader_t>( &Header );	// Swap it to write out:

+	fwrite(&Header,1,sizeof(Header),hOutputFile);

+	g_xzpSwap.SwapFieldsToTargetEndian<xZipHeader_t>( &Header );	// But then swap it back so we can use it in  memory

+

+	// Shut down

+	fclose(hOutputFile);

+

+	// Print the summary

+	printf("\n\nSummary: Input:%u, XZip:%u, Directory Entries:%u (%u preloaded), Preloaded Bytes:%u\n\n",InputFileBytes,OutputFileBytes,Header.DirectoryEntries, Header.PreloadDirectoryEntries, Header.PreloadBytes);

+

+	// Shut down:

+	fclose(hTempFileData);

+	fclose(hTempFilePreload);

+

+	return true;

+}

+

+#define PADD_ID	MAKEID('P','A','D','D')

+

+//-----------------------------------------------------------------------------

+// xZipComputeWAVPreload

+//

+// Returns the number of bytes from a xbox compliant WAV file that should go into 

+// the preload section:

+//-----------------------------------------------------------------------------

+unsigned xZipComputeWAVPreload( char *pFileName )

+{

+	InFileRIFF riff( pFileName, *g_pSndIO );

+	if ( riff.RIFFName() != RIFF_WAVE )

+	{

+		return 0;

+	}

+

+	IterateRIFF walk( riff, riff.RIFFSize() );

+

+	while ( walk.ChunkAvailable() )

+	{

+		// xbox compliant wavs have a single PADD chunk

+		if ( walk.ChunkName() == PADD_ID )

+		{

+			// want to preload data up through PADD chunk header

+			// and not the actual pad bytes

+			return walk.ChunkFilePosition() + 2*sizeof( int );

+		}

+		walk.ChunkNext();

+	}

+

+	return 0;

+}

+

+

+//-----------------------------------------------------------------------------

+// xZipComputeXWVPreload

+//

+// Returns the number of bytes from a XWV file that should go into the preload

+// section:

+//-----------------------------------------------------------------------------

+unsigned xZipComputeXWVPreload( const char* filename )

+{

+	FILE* hFile = fopen( filename, "rb" );

+	if ( !hFile )

+	{

+		printf( "Failed to open xwv file: %s\n", filename );

+		return 0;

+	}

+

+	// Read and validate the XWV header:

+	xwvHeader_t header;

+	memset( &header, 0, sizeof(header) );

+	fread( &header, 1, sizeof(header), hFile );

+	fclose( hFile );

+	

+	if ( header.id != XWV_ID || header.headerSize != sizeof(header) )

+		return 0;

+

+	return header.GetPreloadSize();

+}

+

+unsigned xZipComputeXTFPreload( const char* filename )

+{

+#if 0 // X360TBD: Not using XTF anymore

+	FILE* hFile = fopen( filename, "rb" );

+	if ( !hFile )

+	{

+		printf("Failed to open file: %s\n", filename);

+		return 0;

+	}

+

+	XTFFileHeader_t header;

+	memset( &header,0, sizeof( header ) );

+	fread( &header,1,sizeof(header),hFile);

+

+	fclose(hFile);

+

+	if ( !strncmp( header.fileTypeString, "XTF", 4 ) )

+		return header.preloadDataSize;

+#endif

+	return 0;

+}

+

+// TODO: ONLY store them in the preload section:

+unsigned xZipComputeVMTPreload( const char* filename )

+{

+	// Store VMT's entirely

+	if ( !strstr(filename,".vmt") )

+		return 0;

+

+	FILE* hFile = fopen( filename, "rb" );

+	if ( !hFile )

+	{

+		printf("Failed to open file: %s\n", filename);

+		return 0;

+	}

+

+	fseek( hFile, 0, SEEK_END );

+	unsigned offset = ftell( hFile );

+	fclose( hFile );

+	return offset;

+}

+

+// TODO: ONLY store them in the preload section:

+unsigned xZipComputeVHVPreload( const char* filename )

+{

+	// Store VMT's entirely

+	if ( !strstr(filename,".vhv") )

+		return 0;

+

+	FILE* hFile = fopen( filename, "rb" );

+	if ( !hFile )

+	{

+		printf("Failed to open file: %s\n", filename);

+		return 0;

+	}

+

+	fclose( hFile );

+

+	// Just load the header:

+	return sizeof(HardwareVerts::FileHeader_t);

+}

+

+unsigned xZipComputeXCSPreload( const char* filename )

+{

+	if( !strstr(filename,".vcs") )

+		return 0;

+

+	FILE* hFile = fopen( filename, "rb" );

+	if ( !hFile )

+	{

+		printf("Failed to open file: %s\n", filename);

+		return 0;

+	}

+

+	XShaderHeader_t header;

+	fread(&header,1,sizeof(XShaderHeader_t), hFile);

+	fseek(hFile,0,SEEK_END);

+	fclose(hFile);

+	

+	if (!header.IsValid())

+		return 0;

+

+	return header.BytesToPreload();

+}

+

+unsigned xZipComputeCustomPreloads( const char* filename )

+{

+	// X360TBD: These all need to act on a utlbuffer

+	Assert( 0 );

+	return 0;

+

+//	strlwr(filename);

+

+	unsigned offset = xZipComputeXWVPreload( filename );

+	if ( offset )

+		return offset;

+

+	offset = xZipComputeVMTPreload( filename );

+	if ( offset )

+		return offset;

+

+	offset = xZipComputeXCSPreload( filename );

+	if ( offset )

+		return offset;

+

+	offset = xZipComputeVHVPreload( filename );

+	if ( offset )

+		return offset;

+

+	return xZipComputeXTFPreload( filename );

+}

+

+#endif // MAKE_GAMEDATA_TOOL