itgmania212121/stepmania/src/Song.cpp

#include "stdafx.h"
/*
-----------------------------------------------------------------------------
 Class: Song

 Desc: Holds metadata for a song and the song's step data.

 Copyright (c) 2001-2002 by the person(s) listed below.  All rights reserved.
	Chris Danford
-----------------------------------------------------------------------------
*/

#include "Notes.h"
#include "RageUtil.h"
#include <math.h>	// for fmod
#include "RageLog.h"
#include "IniFile.h"
#include "Song.h"
#include "NoteData.h"
#include "MsdFile.h"
#include "RageSoundStream.h"
#include "RageException.h"


const int FILE_CACHE_VERSION = 53;	// increment this to force a cache reload (useful when the SM file format changes)


int CompareBPMSegments(const void *arg1, const void *arg2)
{
	// arg1 and arg2 are of type Step**
	BPMSegment* seg1 = (BPMSegment*)arg1;
	BPMSegment* seg2 = (BPMSegment*)arg2;

	float score1 = seg1->m_fStartBeat;
	float score2 = seg2->m_fStartBeat;

	if( score1 == score2 )
		return 0;
	else if( score1 < score2 )
		return -1;
	else
		return 1;
}

void SortBPMSegmentsArray( CArray<BPMSegment,BPMSegment&> &arrayBPMSegments )
{
	qsort( arrayBPMSegments.GetData(), arrayBPMSegments.GetSize(), sizeof(BPMSegment), CompareBPMSegments );
}

int CompareStopSegments(const void *arg1, const void *arg2)
{
	// arg1 and arg2 are of type Step**
	StopSegment* seg1 = (StopSegment*)arg1;
	StopSegment* seg2 = (StopSegment*)arg2;

	float score1 = seg1->m_fStartBeat;
	float score2 = seg2->m_fStartBeat;

	if( score1 == score2 )
		return 0;
	else if( score1 < score2 )
		return -1;
	else
		return 1;
}

void SortStopSegmentsArray( CArray<StopSegment,StopSegment&> &arrayStopSegments )
{
	qsort( arrayStopSegments.GetData(), arrayStopSegments.GetSize(), sizeof(StopSegment), CompareStopSegments );
}

int CompareAnimationSegments(const void *arg1, const void *arg2)
{
	// arg1 and arg2 are of type Step**
	AnimationSegment* seg1 = (AnimationSegment*)arg1;
	AnimationSegment* seg2 = (AnimationSegment*)arg2;

	float score1 = seg1->m_fStartBeat;
	float score2 = seg2->m_fStartBeat;

	if( score1 == score2 )
		return 0;
	else if( score1 < score2 )
		return -1;
	else
		return 1;
}

void SortAnimationSegmentsArray( CArray<AnimationSegment,AnimationSegment&> &arrayAnimationSegments )
{
	qsort( arrayAnimationSegments.GetData(), arrayAnimationSegments.GetSize(), sizeof(AnimationSegment), CompareAnimationSegments );
}


//////////////////////////////
// Song
//////////////////////////////
Song::Song()
{
	m_bChangedSinceSave = false;
	m_fBeat0OffsetInSeconds = 0;
	m_fMusicSampleStartSeconds = 0;
	m_fMusicSampleLengthSeconds = 16;	// start fading out at m_fMusicSampleLengthSeconds-1 seconds
	m_iMusicBytes = 0;
	m_fMusicLengthSeconds = 0;
	m_fFirstBeat = -1;
	m_fLastBeat = -1;
}

Song::~Song()
{
	for( int i=0; i<m_apNotes.GetSize(); i++ )
		SAFE_DELETE( m_apNotes[i] );

	m_apNotes.RemoveAll();
}


void Song::AddBPMSegment( BPMSegment seg )
{
	m_BPMSegments.Add( seg );
	SortBPMSegmentsArray( m_BPMSegments );
}


void Song::AddStopSegment( StopSegment seg )
{
	m_StopSegments.Add( seg );
	SortStopSegmentsArray( m_StopSegments );
}


void Song::AddAnimationSegment( AnimationSegment seg )
{
	m_AnimationSegments.Add( seg );
	SortAnimationSegmentsArray( m_AnimationSegments );
}


void Song::GetBeatAndBPSFromElapsedTime( float fElapsedTime, float &fBeatOut, float &fBPSOut, bool &bFreezeOut )
{
//	LOG->Trace( "GetBeatAndBPSFromElapsedTime( fElapsedTime = %f )", fElapsedTime );
	// This function is a nightmare.  Don't even try to understand it. :-)

	fElapsedTime += m_fBeat0OffsetInSeconds;


	for( int i=0; i<m_BPMSegments.GetSize(); i++ ) // foreach BPMSegment
	{
		BPMSegment &this_seg = m_BPMSegments[i];

		float fStartBeatThisSegment = m_BPMSegments[i].m_fStartBeat;
		bool bIsLastBPMSegment = i==m_BPMSegments.GetSize()-1;
		float fStartBeatNextSegment = bIsLastBPMSegment ? 40000/*inf*/ : m_BPMSegments[i+1].m_fStartBeat; 
		float fBeatsInThisSegment = fStartBeatNextSegment - fStartBeatThisSegment;
		float fBPM = m_BPMSegments[i].m_fBPM;
		float fBPS = fBPM / 60.0f;

		// calculate the number of seconds in this segment
		float fSecondsInThisSegment =  fBeatsInThisSegment / fBPS;
		for( int j=0; j<m_StopSegments.GetSize(); j++ )	// foreach freeze
		{
			if( fStartBeatThisSegment <= m_StopSegments[j].m_fStartBeat  &&  m_StopSegments[j].m_fStartBeat < fStartBeatNextSegment )	
			{
				// this freeze lies within this BPMSegment
				fSecondsInThisSegment += m_StopSegments[j].m_fStopSeconds;
			}
		}


		if( fElapsedTime > fSecondsInThisSegment )
		{
			// this BPMSegement is NOT the current segment
			fElapsedTime -= fSecondsInThisSegment;
		}
		else 
		{
			// this BPMSegment IS the current segment

			float fBeatEstimate = fStartBeatThisSegment + fElapsedTime*fBPS;

			for( int j=0; j<m_StopSegments.GetSize(); j++ )	// foreach freeze
			{
				if( fStartBeatThisSegment <= m_StopSegments[j].m_fStartBeat  &&  m_StopSegments[j].m_fStartBeat <= fStartBeatNextSegment )	
				{
					// this freeze lies within this BPMSegment

					if( m_StopSegments[j].m_fStartBeat <= fBeatEstimate )
					{
						fElapsedTime -= m_StopSegments[j].m_fStopSeconds;
						// re-estimate
						fBeatEstimate = fStartBeatThisSegment + fElapsedTime*fBPS;
						if( fBeatEstimate < m_StopSegments[j].m_fStartBeat )
						{
							fBeatOut = m_StopSegments[j].m_fStartBeat;
							fBPSOut = fBPS;
							bFreezeOut = true;
							return;
						}
					}
					else
						break;
				}
			}

			fBeatOut = fBeatEstimate;
			fBPSOut = fBPS;
			bFreezeOut = false;
			return;
		}

	}
}


// This is a super hack, but it's only called from ScreenEdit, so it's OK :-)
// Writing an inverse function of GetBeatAndBPSFromElapsedTime() is impossible,
// so do a binary search to get close to the correct elapsed time.
float Song::GetElapsedTimeFromBeat( float fBeat )
{
	float fElapsedTimeBestGuess = 100;	//  seconds
	float fSecondsToMove = fElapsedTimeBestGuess;	//  seconds
	float fBeatOut, fBPSOut;
	bool bFreezeOut;

	while( fSecondsToMove > 0.1f )
	{
		GetBeatAndBPSFromElapsedTime( fElapsedTimeBestGuess, fBeatOut, fBPSOut, bFreezeOut );
		if( fBeatOut > fBeat )
			fElapsedTimeBestGuess -= fSecondsToMove;
		else
			fElapsedTimeBestGuess += fSecondsToMove;

		fSecondsToMove /= 2;
	}

	return fElapsedTimeBestGuess;
}

void Song::GetMainAndSubTitlesFromFullTitle( const CString sFullTitle, CString &sMainTitleOut, CString &sSubTitleOut )
{
	const CString sLeftSeps[]  = { " -", " ~", " (", " [" };
	int iNumSeps = sizeof(sLeftSeps)/sizeof(CString);
	for( int i=0; i<iNumSeps; i++ )
	{
		int iBeginIndex = sFullTitle.Find( sLeftSeps[i] );
		if( iBeginIndex == -1 )
			continue;
		sMainTitleOut = sFullTitle.Left( iBeginIndex );
		sSubTitleOut = sFullTitle.Mid( iBeginIndex+1, sFullTitle.GetLength()-iBeginIndex+1 );
		return;
	}
	sMainTitleOut = sFullTitle; 
	sSubTitleOut = ""; 
};	

CString Song::GetCacheFilePath()
{
	return ssprintf( "Cache\\%d", GetHashForString(m_sSongDir) );
}

CString Song::GetSongFilePath()
{
	CStringArray asFileNames;
	GetDirListing( m_sSongDir+"*.sm", asFileNames );
	if( asFileNames.GetSize() > 0 )
		return m_sSongDir + asFileNames[0];
	else
		return m_sSongDir + GetFullTitle() + ".sm";
}

bool Song::LoadFromSongDir( CString sDir )
{
	LOG->Trace( "Song::LoadFromSongDir(%s)", sDir );

	// make sure there is a trailing '\\' at the end of sDir
	if( sDir.Right(1) != "\\" )
		sDir += "\\";

	// save song dir
	m_sSongDir = sDir;

	// save group name
	CStringArray sDirectoryParts;
	split( m_sSongDir, "\\", sDirectoryParts, false );
	m_sGroupName = sDirectoryParts[sDirectoryParts.GetSize()-3];	// second from last item


	//
	// First look in the cache for this song (without loading NoteData)
	//
	IniFile ini;
	ini.SetPath( "Cache\\index.cache" );
	if( !ini.ReadFile() )
		goto load_without_cache;

	int iCacheVersion;
	ini.GetValueI( "Cache", "CacheVersion", iCacheVersion );
	if( iCacheVersion != FILE_CACHE_VERSION )
	{
		LOG->Trace( "Cache format is out of date.  Deleting all cache files." );
		CStringArray asCacheFileNames;
		GetDirListing( "Cache\\*.*", asCacheFileNames );
		for( int i=0; i<asCacheFileNames.GetSize(); i++ )
			DeleteFile( "Cache\\" + asCacheFileNames[i] );
		goto load_without_cache;
	}

	int iDirHash;
	ini.GetValueI( "Cache", m_sSongDir, iDirHash );
	if( GetHashForDirectory(m_sSongDir) == iDirHash )	// this cache is up to date
	{
		if( !DoesFileExist(GetCacheFilePath()) )
			goto load_without_cache;
		LoadFromSMFile( GetCacheFilePath() );

		LOG->Trace( "Loading '%s' from cache file '%s'.", m_sSongDir, GetCacheFilePath() );
		return true;
	}

load_without_cache:
	//
	// There was no entry in the cache for this song.
	// Let's load it from a file, then write a cache entry.
	//
	CStringArray arrayBMSFileNames;
	GetDirListing( sDir + CString("*.bms"), arrayBMSFileNames );
	int iNumBMSFiles = arrayBMSFileNames.GetSize();

	CStringArray arrayKSFFileNames;
	GetDirListing( sDir + CString("*.ksf"), arrayKSFFileNames );
	int iNumKSFFiles = arrayKSFFileNames.GetSize();

	CStringArray arrayDWIFileNames;
	GetDirListing( sDir + CString("*.dwi"), arrayDWIFileNames );
	int iNumDWIFiles = arrayDWIFileNames.GetSize();

	CStringArray arraySMFileNames;
	GetDirListing( sDir + CString("*.sm"), arraySMFileNames );
	int iNumSMFiles = arraySMFileNames.GetSize();


	if( iNumSMFiles > 1 )
		throw RageException( "There is more than one SM file in '%s'.  There should be only one!", sDir );
	else if( iNumDWIFiles > 1 )
		throw RageException( "There is more than one DWI file in '%s'.  There should be only one!", sDir );
	else if( iNumSMFiles == 1 )
		LoadFromSMFile( sDir + arraySMFileNames[0] );	// do load note data
	else if( iNumDWIFiles == 1 )
		LoadFromDWIFile( sDir + arrayDWIFileNames[0] );
	else if( iNumBMSFiles > 0 )
		LoadFromBMSDir( sDir );
	else if( iNumKSFFiles > 0 )
		LoadFromKSFDir( sDir );
	else 
	{
		LOG->Warn( "Couldn't find any SM, DWI, BMS, or KSF files in '%s'.  This is not a valid song directory.", sDir );
		return false;
	}

	TidyUpData();

	SaveToCacheFile();	// save a cahce file so we don't have to parse it all over again next time

	return true;
}



bool Song::LoadFromBMSDir( CString sDir )
{
	LOG->Trace( "Song::LoadFromBMSDir(%s)", sDir );

	CStringArray arrayBMSFileNames;
	GetDirListing( sDir + CString("*.bms"), arrayBMSFileNames );

	if( arrayBMSFileNames.GetSize() == 0 )
		throw RageException( "Couldn't find any BMS files in '%s'", sDir );

	// load the Notes from the rest of the BMS files
	for( int i=0; i<arrayBMSFileNames.GetSize(); i++ ) 
	{
		Notes* pNewNotes = new Notes;
		pNewNotes->LoadFromBMSFile( m_sSongDir + arrayBMSFileNames[i] );
		m_apNotes.Add( pNewNotes );
	}

	CString sPath = m_sSongDir + arrayBMSFileNames[0];

	CStdioFile file;	
	if( !file.Open( sPath, CFile::modeRead|CFile::shareDenyNone ) )
	{
		throw RageException( "Failed to open %s.", sPath );
		return false;
	}

	CString line;
	while( file.ReadString(line) )	// foreach line
	{
		CString value_name;		// fill these in
		CString value_data;	

		// BMS value names can be separated by a space or a colon.
		int iIndexOfFirstColon = line.Find( ":" );
		int iIndexOfFirstSpace = line.Find( " " );

		if( iIndexOfFirstColon == -1 )
			iIndexOfFirstColon = 10000;
		if( iIndexOfFirstSpace == -1 )
			iIndexOfFirstSpace = 10000;
		
		int iIndexOfSeparator = min( iIndexOfFirstSpace, iIndexOfFirstColon );

		if( iIndexOfSeparator != 10000 )
		{
			value_name = line.Mid( 0, iIndexOfSeparator );
			value_data = line;	// the rest
			value_data.Delete(0,iIndexOfSeparator+1);
		}
		else	// no separator
		{
			value_name = line;
		}


		value_name.MakeLower();


		// handle the data
		if( value_name == "#title" ) 
		{
			// strip Notes type out of description leaving only song title - looks like 'B4U <BASIC>'
			int iIndex = value_data.ReverseFind('<');
			if( iIndex == -1 )
				iIndex = value_data.ReverseFind('(');
			if( iIndex != -1 )
			{
				value_data = value_data.Left( iIndex );
				GetMainAndSubTitlesFromFullTitle( value_data, m_sMainTitle, m_sSubTitle );
			}
			else
				m_sMainTitle = value_data;
		}
		else if( value_name == "#artist" ) 
		{
			m_sArtist = value_data;
		}
		else if( value_name == "#bpm" ) 
		{
			BPMSegment newSeg( 0, (float)atof(value_data) );
			AddBPMSegment( newSeg );
		
			LOG->Trace( "Inserting new BPM change at beat %f, BPM %f", newSeg.m_fStartBeat, newSeg.m_fBPM );
		}
		else if( value_name == "#backbmp" ) 
		{
			m_sBackgroundFile = value_data;
		}
		else if( value_name == "#wav" ) 
		{
			m_sMusicFile = value_data;
		}
		else if( value_name.Left(1) == "#"  
			 && IsAnInt( value_name.Mid(1,3) )
			 && IsAnInt( value_name.Mid(4,2) ) )	// this is step or offset data.  Looks like "#00705"
		{
			int iMeasureNo	= atoi( value_name.Mid(1,3) );
			int iBMSTrackNo	= atoi( value_name.Mid(4,2) );

			CString sNoteData = value_data;
			CArray<int, int> arrayNotes;

			for( int i=0; i<sNoteData.GetLength(); i+=2 )
			{
				CString sNote = sNoteData.Mid(i,2);
				int iNote;
				sscanf( sNote, "%x", &iNote );	// data is in hexadecimal
				arrayNotes.Add( iNote );
			}

			const int iNumNotesInThisMeasure = arrayNotes.GetSize();
			//LOG->Trace( "%s:%s: iMeasureNo = %d, iBMSTrackNo = %d, iNumNotesInThisMeasure = %d", 
			//	valuename, sNoteData, iMeasureNo, iBMSTrackNo, iNumNotesInThisMeasure );
			for( int j=0; j<iNumNotesInThisMeasure; j++ )
			{
				if( arrayNotes[j] != 0 )
				{
					float fPercentThroughMeasure = (float)j/(float)iNumNotesInThisMeasure;

					// index is in quarter beats starting at beat 0
					int iStepIndex = (int) ( (iMeasureNo + fPercentThroughMeasure)
									 * BEATS_PER_MEASURE * ELEMENTS_PER_BEAT );

					switch( iBMSTrackNo )
					{
					case 1:	// background music track
						{
							float fBeatOffset = fBeatOffset = NoteRowToBeat( (float)iStepIndex );
							if( fBeatOffset > 10 )	// some BPMs's play the music again at the end.  Why?  Who knows...
								break;
							float fBPS;
							fBPS = m_BPMSegments[0].m_fBPM/60.0f;
							m_fBeat0OffsetInSeconds = fBeatOffset / fBPS;
							//LOG->Trace( "Found offset to be index %d, beat %f", iStepIndex, NoteRowToBeat(iStepIndex) );
						}
						break;
					case 3:	// bpm change
						{
							BPMSegment newSeg( NoteRowToBeat(iStepIndex), (float)arrayNotes[j] );
							AddBPMSegment( newSeg );
							LOG->Trace( "Inserting new BPM change at beat %f, BPM %f", newSeg.m_fStartBeat, newSeg.m_fBPM );
						}
						break;

						// Let me just take a moment to express how frustrated I am with the new, 
						// poorly-designed changes to the BMS format.
						//
						//
						// AAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaahhhhhhhhhhhhhhhhhhhhhhhh!!!!!!!!!!!!!!!
						//
						// Thank you.

					case 8:	// indirect bpm
						{
							// This is a very inefficient way to parse, but it doesn't matter much
							// because this is only parsed on the first run after the song is installed.
							CString sTagToLookFor = ssprintf( "#BPM%02x", arrayNotes[j] );
							float fBPM = -1;


							// open the song file again and and look for this tag's value
							CStdioFile file;	
							if( !file.Open( sPath, CFile::modeRead|CFile::shareDenyNone ) )
							{
								throw RageException( "Failed to open %s.", sPath );
								return false;
							}

							CString line;
							while( file.ReadString(line) )	// foreach line
							{
								CString value_name;		// fill these in
								CString value_data;	

								// BMS value names can be separated by a space or a colon.
								int iIndexOfFirstColon = line.Find( ":" );
								int iIndexOfFirstSpace = line.Find( " " );

								if( iIndexOfFirstColon == -1 )
									iIndexOfFirstColon = 10000;
								if( iIndexOfFirstSpace == -1 )
									iIndexOfFirstSpace = 10000;
								
								int iIndexOfSeparator = min( iIndexOfFirstSpace, iIndexOfFirstColon );

								if( iIndexOfSeparator != 10000 )
								{
									value_name = line.Mid( 0, iIndexOfSeparator );
									value_data = line;	// the rest
									value_data.Delete(0,iIndexOfSeparator+1);
								}
								else	// no separator
								{
									value_name = line;
								}

								if( 0==stricmp(value_name, sTagToLookFor) == 0 )
								{
									fBPM = (float)atof( value_data );
									break;
								}
							}

							if( fBPM == -1 )	// we didn't find the line we were looking for
							{
								LOG->Trace( "WARNING:  Couldn't find tag '%s' in '%s'.", sTagToLookFor, sPath );
							}
							else
							{
								BPMSegment newSeg( NoteRowToBeat(iStepIndex), fBPM );
								AddBPMSegment( newSeg );
								LOG->Trace( "Inserting new BPM change at beat %f, BPM %f", newSeg.m_fStartBeat, newSeg.m_fBPM );
							}

							file.Close();
						}
						break;
					case 9:	// stop
						{
							// This is a very inefficient way to parse, but it doesn't 
							// matter much because this is only parsed on the first run after the song is installed.
							CString sTagToLookFor = ssprintf( "#STOP%02x", arrayNotes[j] );
							float fFreezeStartBeat = NoteRowToBeat(iStepIndex);
							float fFreezeSecs = -1;


							// open the song file again and and look for this tag's value
							CStdioFile file;	
							if( !file.Open( sPath, CFile::modeRead|CFile::shareDenyNone ) )
								throw RageException( "Failed to open %s.", sPath );

							CString line;
							while( file.ReadString(line) )	// foreach line
							{
								CString value_name;		// fill these in
								CString value_data;	

								// BMS value names can be separated by a space or a colon.
								int iIndexOfFirstColon = line.Find( ":" );
								int iIndexOfFirstSpace = line.Find( " " );

								if( iIndexOfFirstColon == -1 )
									iIndexOfFirstColon = 10000;
								if( iIndexOfFirstSpace == -1 )
									iIndexOfFirstSpace = 10000;
								
								int iIndexOfSeparator = min( iIndexOfFirstSpace, iIndexOfFirstColon );

								if( iIndexOfSeparator != 10000 )
								{
									value_name = line.Mid( 0, iIndexOfSeparator );
									value_data = line;	// the rest
									value_data.Delete(0,iIndexOfSeparator+1);
								}
								else	// no separator
								{
									value_name = line;
								}

								if( 0==stricmp(value_name, sTagToLookFor) )
								{
									// find the BPM at the time of this freeze
									float fBPM = -1;
									for( int i=0; i<m_BPMSegments.GetSize()-1; i++ )
									{
										if( m_BPMSegments[i].m_fStartBeat <= fFreezeStartBeat && 
											m_BPMSegments[i+1].m_fStartBeat > fFreezeStartBeat )
										{
											fBPM = m_BPMSegments[i].m_fBPM;
											break;
										}
									}
									// the BPM segment of this beat is the last BPM segment
									if( fBPM == -1 )
										fBPM = m_BPMSegments[m_BPMSegments.GetSize()-1].m_fBPM;

									fFreezeSecs = (float)atof(value_data)/(fBPM*0.81f);	// I have no idea what units these are in, so I experimented until finding this factor.
									break;
								}
							}

							if( fFreezeSecs == -1 )	// we didn't find the line we were looking for
							{
								LOG->Trace( "WARNING:  Couldn't find tag '%s' in '%s'.", sTagToLookFor, sPath );
							}
							else
							{
								StopSegment newSeg( fFreezeStartBeat, fFreezeSecs );
								AddStopSegment( newSeg );
								LOG->Trace( "Inserting new Freeze at beat %f, secs %f", newSeg.m_fStartBeat, newSeg.m_fStopSeconds );
							}

							file.Close();
						}
						break;
					}
				}
			}
		}
	}

	for( i=0; i<m_BPMSegments.GetSize(); i++ )
		LOG->Trace( "There is a BPM change at beat %f, BPM %f, index %d", 
					m_BPMSegments[i].m_fStartBeat, m_BPMSegments[i].m_fBPM, i );

	file.Close();

	return TRUE;
}


bool Song::LoadFromDWIFile( CString sPath )
{
	LOG->Trace( "Song::LoadFromDWIFile(%s)", sPath );
	

	MsdFile msd;
	bool bResult = msd.ReadFile( sPath );
	if( !bResult )
		throw RageException( "Error opening file '%s'.", sPath );

	for( int i=0; i<msd.m_iNumValues; i++ )
	{
		int iNumParams = msd.m_iNumParams[i];
		CString* sParams = msd.m_sValuesAndParams[i];
		CString sValueName = sParams[0];

		// handle the data
		if( 0==stricmp(sValueName,"FILE") )
			m_sMusicFile = sParams[1];

		else if( 0==stricmp(sValueName,"TITLE") )
			GetMainAndSubTitlesFromFullTitle( sParams[1], m_sMainTitle, m_sSubTitle );

		else if( 0==stricmp(sValueName,"ARTIST") )
			m_sArtist = sParams[1];

		else if( 0==stricmp(sValueName,"CDTITLE") )
			m_sCDTitleFile = sParams[1];

		else if( 0==stricmp(sValueName,"BPM") )
			AddBPMSegment( BPMSegment(0, (float)atof(sParams[1])) );		

		else if( 0==stricmp(sValueName,"GAP") )
			// the units of GAP is 1/1000 second
			m_fBeat0OffsetInSeconds = -atoi( sParams[1] ) / 1000.0f;

		else if( 0==stricmp(sValueName,"SAMPLESTART") )
			m_fMusicSampleStartSeconds = TimeToSeconds( sParams[1] );

		else if( 0==stricmp(sValueName,"SAMPLELENGTH") )
			m_fMusicSampleLengthSeconds = TimeToSeconds(  sParams[1] );

		else if( 0==stricmp(sValueName,"FREEZE") )
		{
			CStringArray arrayFreezeExpressions;
			split( sParams[1], ",", arrayFreezeExpressions );

			for( int f=0; f<arrayFreezeExpressions.GetSize(); f++ )
			{
				CStringArray arrayFreezeValues;
				split( arrayFreezeExpressions[f], "=", arrayFreezeValues );
				float fIndex = atoi( arrayFreezeValues[0] ) * ELEMENTS_PER_BEAT / 4.0f;
				float fFreezeBeat = NoteRowToBeat( fIndex );
				float fFreezeSeconds = (float)atof( arrayFreezeValues[1] ) / 1000.0f;
				
				AddStopSegment( StopSegment(fFreezeBeat, fFreezeSeconds) );
				LOG->Trace( "Adding a freeze segment: beat: %f, seconds = %f", fFreezeBeat, fFreezeSeconds );
			}
		}

		else if( 0==stricmp(sValueName,"CHANGEBPM")  || 0==stricmp(sValueName,"BPMCHANGE") )
		{
			CStringArray arrayBPMChangeExpressions;
			split( sParams[1], ",", arrayBPMChangeExpressions );

			for( int b=0; b<arrayBPMChangeExpressions.GetSize(); b++ )
			{
				CStringArray arrayBPMChangeValues;
				split( arrayBPMChangeExpressions[b], "=", arrayBPMChangeValues );
				float fIndex = atoi( arrayBPMChangeValues[0] ) * ELEMENTS_PER_BEAT / 4.0f;
				float fBeat = NoteRowToBeat( fIndex );
				float fNewBPM = (float)atof( arrayBPMChangeValues[1] );
				
				AddBPMSegment( BPMSegment(fBeat, fNewBPM) );
			}
		}

		else if( 0==stricmp(sValueName,"SINGLE")  || 
			     0==stricmp(sValueName,"DOUBLE")  ||
				 0==stricmp(sValueName,"COUPLE")  || 
				 0==stricmp(sValueName,"SOLO"))
		{
			Notes* pNewNotes = new Notes;
			pNewNotes->LoadFromDWITokens( 
				sParams[0], 
				sParams[1], 
				sParams[2], 
				sParams[3], 
				(iNumParams==5) ? sParams[4] : "" 
				);
			m_apNotes.Add( pNewNotes );
		}
		else
			// do nothing.  We don't care about this value name
			;
	}

	return TRUE;
}


bool Song::LoadFromSMFile( CString sPath )
{
	LOG->Trace( "Song::LoadFromSMDir(%s)", sPath );

	m_BPMSegments.RemoveAll();
	m_StopSegments.RemoveAll();

	int i;

	MsdFile msd;
	bool bResult = msd.ReadFile( sPath );
	if( !bResult )
		throw RageException( "Error opening file '%s'.", sPath );

	for( i=0; i<msd.m_iNumValues; i++ )
	{
		int iNumParams = msd.m_iNumParams[i];
		CString* sParams = msd.m_sValuesAndParams[i];
		CString sValueName = sParams[0];

		// handle the data
		if( 0==stricmp(sValueName,"TITLE") )
			GetMainAndSubTitlesFromFullTitle( sParams[1], m_sMainTitle, m_sSubTitle );

		else if( 0==stricmp(sValueName,"SUBTITLE") )
			m_sSubTitle = sParams[1];

		else if( 0==stricmp(sValueName,"ARTIST") )
			m_sArtist = sParams[1];

		else if( 0==stricmp(sValueName,"CREDIT") )
			m_sCredit = sParams[1];

		else if( 0==stricmp(sValueName,"BANNER") )
			m_sBannerFile = sParams[1];

		else if( 0==stricmp(sValueName,"BACKGROUND") )
			m_sBackgroundFile = sParams[1];

		else if( 0==stricmp(sValueName,"CDTITLE") )
			m_sCDTitleFile = sParams[1];

		else if( 0==stricmp(sValueName,"MOVIEBACKGROUND") )
			m_sMovieBackgroundFile = sParams[1];

		else if( 0==stricmp(sValueName,"MUSIC") )
			m_sMusicFile = sParams[1];

		else if( 0==stricmp(sValueName,"MUSICBYTES") )
			m_iMusicBytes = atoi( sParams[1] );

		else if( 0==stricmp(sValueName,"MUSICLENGTH") )
			m_fMusicLengthSeconds = (float)atof( sParams[1] );

		else if( 0==stricmp(sValueName,"FIRSTBEAT") )
			m_fFirstBeat = (float)atof( sParams[1] );

		else if( 0==stricmp(sValueName,"LASTBEAT") )
			m_fLastBeat = (float)atof( sParams[1] );

		else if( 0==stricmp(sValueName,"SAMPLESTART") )
			m_fMusicSampleStartSeconds = TimeToSeconds( sParams[1] );

		else if( 0==stricmp(sValueName,"SAMPLELENGTH") )
			m_fMusicSampleLengthSeconds = TimeToSeconds( sParams[1] );

		else if( 0==stricmp(sValueName,"OFFSET") )
			m_fBeat0OffsetInSeconds = (float)atof( sParams[1] );

		else if( 0==stricmp(sValueName,"STOPS") || 0==stricmp(sValueName,"FREEZES") )
		{
			CStringArray arrayFreezeExpressions;
			split( sParams[1], ",", arrayFreezeExpressions );

			for( int f=0; f<arrayFreezeExpressions.GetSize(); f++ )
			{
				CStringArray arrayFreezeValues;
				split( arrayFreezeExpressions[f], "=", arrayFreezeValues );
				float fFreezeBeat = (float)atof( arrayFreezeValues[0] );
				float fFreezeSeconds = (float)atof( arrayFreezeValues[1] );
				
				StopSegment new_seg;
				new_seg.m_fStartBeat = fFreezeBeat;
				new_seg.m_fStopSeconds = fFreezeSeconds;

				LOG->Trace( "Adding a freeze segment: beat: %f, seconds = %f", new_seg.m_fStartBeat, new_seg.m_fStopSeconds );

				AddStopSegment( new_seg );
			}
		}

		else if( 0==stricmp(sValueName,"BPMS") )
		{
			CStringArray arrayBPMChangeExpressions;
			split( sParams[1], ",", arrayBPMChangeExpressions );

			for( int b=0; b<arrayBPMChangeExpressions.GetSize(); b++ )
			{
				CStringArray arrayBPMChangeValues;
				split( arrayBPMChangeExpressions[b], "=", arrayBPMChangeValues );
				float fBeat = (float)atof( arrayBPMChangeValues[0] );
				float fNewBPM = (float)atof( arrayBPMChangeValues[1] );
				
				BPMSegment new_seg;
				new_seg.m_fStartBeat = fBeat;
				new_seg.m_fBPM = fNewBPM;
				
				AddBPMSegment( new_seg );
			}
		}

		else if( 0==stricmp(sValueName,"ANIMATIONS") )
		{
			CStringArray arrayAnimationExpressions;
			split( sParams[1], ",", arrayAnimationExpressions );

			for( int b=0; b<arrayAnimationExpressions.GetSize(); b++ )
			{
				CStringArray arrayAnimationValues;
				split( arrayAnimationExpressions[b], "=", arrayAnimationValues );
				float fBeat = (float)atof( arrayAnimationValues[0] );
				CString sAnimName = arrayAnimationValues[1];
				sAnimName.MakeLower();
				
				AddAnimationSegment( AnimationSegment(fBeat, sAnimName) );
			}
		}

		else if( 0==stricmp(sValueName,"NOTES") )
		{
			Notes* pNewNotes = new Notes;
			ASSERT( pNewNotes );
			m_apNotes.Add( pNewNotes );

			if( iNumParams != 7 )
				throw RageException( "The song file '%s' is has %d fields in a #NOTES tag, but should have %d.", sPath, iNumParams, 7 );

			pNewNotes->LoadFromSMTokens( 
				sParams[1], 
				sParams[2], 
				sParams[3], 
				sParams[4], 
				sParams[5], 
				sParams[6]
				);
		}

		else
			LOG->Trace( "Unexpected value named '%s'", sValueName );
	}

	return TRUE;
}


bool Song::LoadFromKSFDir( CString sDir )
{
	LOG->Trace( "Song::LoadFromKSFDir(%s)", sDir );

	CStringArray arrayKSFFileNames;
	GetDirListing( sDir + CString("*.ksf"), arrayKSFFileNames );

	if( arrayKSFFileNames.GetSize() == 0 )
		throw RageException( "Couldn't find any KSF files in '%s'", sDir );

	// load the Notes from the rest of the KSF files
	for( int i=0; i<arrayKSFFileNames.GetSize(); i++ ) 
	{
		Notes* pNewNotes = new Notes;
		pNewNotes->LoadFromKSFFile( m_sSongDir + arrayKSFFileNames[i] );
		m_apNotes.Add( pNewNotes );
	}

	CString sPath = m_sSongDir + arrayKSFFileNames[0];

	MsdFile msd;
	bool bResult = msd.ReadFile( sPath );
	if( !bResult )
		throw RageException( "Error opening file '%s'.", sPath );

	for( i=0; i<msd.m_iNumValues; i++ )
	{
		int iNumParams = msd.m_iNumParams[i];
		CString* sParams = msd.m_sValuesAndParams[i];
		CString sValueName = sParams[0];

		// handle the data
		if( 0==stricmp(sValueName,"TITLE") )
		{
			//title is usually in format "artist - songtitle"
			CStringArray asBits;
			split( sParams[1], " - ", asBits, false );

			if( asBits.GetSize() == 2 )
			{
				m_sArtist = asBits[0];
				m_sMainTitle = asBits[1];
			}
			else
			{
				m_sMainTitle = asBits[0];
			}
		}

		else if( 0==stricmp(sValueName,"BPM") )
			AddBPMSegment( BPMSegment(0, (float)atof(sParams[1])) );		

		else if( 0==stricmp(sValueName,"STARTTIME") )
			m_fBeat0OffsetInSeconds = -(float)atof(sParams[1])/100;		

		else
			LOG->Trace( "Unexpected value named '%s'", sValueName );
	}

	m_sMusicFile = "song.mp3";

	return TRUE;
}


void Song::TidyUpData()
{
	m_sMainTitle.TrimRight();
	if( m_sMainTitle == "" )	m_sMainTitle = "Untitled song";
	m_sSubTitle.TrimRight();
	if( m_sArtist == "" )		m_sArtist = "Unknown artist";
	if( m_BPMSegments.GetSize() == 0 )
		throw RageException( "No #BPM specified in '%s.'", GetSongFilePath() );

	if( !HasMusic() )
	{
		CStringArray arrayPossibleMusic;
		GetDirListing( m_sSongDir + CString("*.mp3"), arrayPossibleMusic );
		GetDirListing( m_sSongDir + CString("*.ogg"), arrayPossibleMusic );
		GetDirListing( m_sSongDir + CString("*.wav"), arrayPossibleMusic );

		if( arrayPossibleMusic.GetSize() > 0 )		// we found a match
			m_sMusicFile = arrayPossibleMusic[0];
		else
			throw RageException( "The song in '%s' is missing a music file.  You must place a music file in the song folder or remove the song", m_sSongDir );
	}

	RageSoundStream sound;
	sound.Load( GetMusicPath() );
	m_fMusicLengthSeconds = sound.GetLengthSeconds();



	//
	// Here's the problem:  We have a directory full of images.  We want to determine which 
	// image is the banner, which is the background, and which is the CDTitle.
	//

	//
	// First, check the file name for hints.
	//
	if( !HasBanner() )
	{
		m_sBannerFile = "";

		// find an image with "banner" in the file name
		CStringArray arrayPossibleBanners;
		GetDirListing( m_sSongDir + CString("*banner*.png"), arrayPossibleBanners );
		GetDirListing( m_sSongDir + CString("*banner*.jpg"), arrayPossibleBanners );
		GetDirListing( m_sSongDir + CString("*banner*.bmp"), arrayPossibleBanners );
		GetDirListing( m_sSongDir + CString("*banner*.gif"), arrayPossibleBanners );
		if( arrayPossibleBanners.GetSize() > 0 )
			m_sBannerFile = arrayPossibleBanners[0];
	}

	if( !HasBackground() )
	{
		m_sBackgroundFile = "";

		// find an image with "bg" or "background" in the file name
		CStringArray arrayPossibleBGs;
		GetDirListing( m_sSongDir + CString("*bg*.png"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*bg*.jpg"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*bg*.bmp"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*bg*.gif"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*background*.png"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*background*.jpg"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*background*.bmp"), arrayPossibleBGs );
		GetDirListing( m_sSongDir + CString("*background*.gif"), arrayPossibleBGs );
		if( arrayPossibleBGs.GetSize() > 0 )
			m_sBackgroundFile = arrayPossibleBGs[0];
	}

	if( !HasCDTitle() )
	{
		m_sCDTitleFile = "";

		// find an image with "cdtitle" in the file name
		CStringArray arrayPossibleCDTitles;
		GetDirListing( m_sSongDir + CString("*cdtitle*.png"), arrayPossibleCDTitles );
		GetDirListing( m_sSongDir + CString("*cdtitle*.jpg"), arrayPossibleCDTitles );
		GetDirListing( m_sSongDir + CString("*cdtitle*.bmp"), arrayPossibleCDTitles );
		GetDirListing( m_sSongDir + CString("*cdtitle*.gif"), arrayPossibleCDTitles );
		if( arrayPossibleCDTitles.GetSize() > 0 )
			m_sCDTitleFile = arrayPossibleCDTitles[0];
	}


	//
	// Now, For the images we still haven't found, look at the image dimensions of the remaining unclassified images.
	//
	CStringArray arrayImages;
	GetDirListing( m_sSongDir + CString("*.png"), arrayImages );
	GetDirListing( m_sSongDir + CString("*.jpg"), arrayImages );
	GetDirListing( m_sSongDir + CString("*.bmp"), arrayImages );
	GetDirListing( m_sSongDir + CString("*.gif"), arrayImages );

	for( int i=0; i<arrayImages.GetSize(); i++ )	// foreach image
	{
		// Skip any image that we've already classified

		if( HasBanner()  &&  stricmp(m_sBannerFile, arrayImages[i])==0 )
			continue;	// skip

		if( HasBackground()  &&  stricmp(m_sBackgroundFile, arrayImages[i])==0 )
			continue;	// skip

		if( HasCDTitle()  &&  stricmp(m_sCDTitleFile, arrayImages[i])==0 )
			continue;	// skip

		D3DXIMAGE_INFO ddii;
		if( !FAILED( D3DXGetImageInfoFromFile( m_sSongDir + arrayImages[i], &ddii ) ) )
		{
			if( !HasBackground()  &&  ddii.Width >= 320  &&  ddii.Height >= 240 )
			{
				m_sBackgroundFile = arrayImages[i];
				continue;
			}
			if( !HasBanner()  &&  100 < ddii.Width &&  ddii.Width < 320  &&  50 < ddii.Height  &&  ddii.Height < 240 )
			{
				m_sBannerFile = arrayImages[i];
				continue;
			}
			if( !HasCDTitle()  &&  ddii.Width <= 100  &&  ddii.Height <= 50 )
			{
				m_sCDTitleFile = arrayImages[i];
				continue;
			}
		}
	}



	if( !HasMovieBackground() )
	{
		CStringArray arrayPossibleMovies;
		GetDirListing( m_sSongDir + CString("*movie*.avi"), arrayPossibleMovies );
		GetDirListing( m_sSongDir + CString("*movie*.mpg"), arrayPossibleMovies );
		GetDirListing( m_sSongDir + CString("*movie*.mpeg"), arrayPossibleMovies );
		GetDirListing( m_sSongDir + CString("*.avi"), arrayPossibleMovies );
		GetDirListing( m_sSongDir + CString("*.mpg"), arrayPossibleMovies );
		GetDirListing( m_sSongDir + CString("*.mpeg"), arrayPossibleMovies );
		if( arrayPossibleMovies.GetSize() > 0 )
			m_sMovieBackgroundFile = arrayPossibleMovies[0];
	}

	//
	// calculate radar values and first/last beat
	//
	for( i=0; i<m_apNotes.GetSize(); i++ )
	{
		Notes* pNotes = m_apNotes[i];
		NoteData tempNoteData;
		pNotes->GetNoteData( &tempNoteData );

		for( int r=0; r<NUM_RADAR_VALUES; r++ )
			pNotes->m_fRadarValues[r] = tempNoteData.GetRadarValue( (RadarCategory)r, m_fMusicLengthSeconds );

		float fFirstBeat = tempNoteData.GetFirstBeat();
		float fLastBeat = tempNoteData.GetLastBeat();
		if( m_fFirstBeat == -1 )
			m_fFirstBeat = fFirstBeat;
		else
			m_fFirstBeat = min( m_fFirstBeat, fFirstBeat );
		if( m_fLastBeat == -1 )
			m_fLastBeat = fLastBeat;
		else
			m_fLastBeat = max( m_fLastBeat, fLastBeat );
	}
}


void Song::GetNotesThatMatch( NotesType nt, CArray<Notes*, Notes*>& arrayAddTo )
{
	for( int i=0; i<m_apNotes.GetSize(); i++ )	// for each of the Song's Notes
		if( m_apNotes[i]->m_NotesType == nt )
			arrayAddTo.Add( m_apNotes[i] );
}

void Song::SaveToCacheFile()
{
	LOG->Trace( "Song::SaveToCacheFile()" );

	//
	// First look in the cache for this song (without loading NoteData)
	//
	IniFile ini;
	ini.SetPath( "Cache\\index.cache" );
	ini.ReadFile();	// don't care if this fails

	ini.SetValueI( "Cache", "CacheVersion", FILE_CACHE_VERSION );
	ini.SetValueI( "Cache", m_sSongDir, GetHashForDirectory(m_sSongDir) );
	ini.WriteFile();
	SaveToSMFile( GetCacheFilePath() );
}


void Song::SaveToSMFile( CString sPath )
{
	if( sPath == "" )
	{
		sPath = GetSongFilePath();

		//
		// rename all old files to avoid confusion
		//
		CStringArray arrayOldFileNames;
		GetDirListing( m_sSongDir + "*.bms", arrayOldFileNames );
		GetDirListing( m_sSongDir + "*.dwi", arrayOldFileNames );
		GetDirListing( m_sSongDir + "*.ksf", arrayOldFileNames );
		
		for( int i=0; i<arrayOldFileNames.GetSize(); i++ )
		{
			CString sOldPath = m_sSongDir + arrayOldFileNames[i];
			CString sNewPath = sOldPath + ".old";
			MoveFile( sOldPath, sNewPath );
		}
	}


	LOG->Trace( "Song::SaveToSMDir('%s')", sPath );

	int i;

	FILE* fp = fopen( sPath, "w" );	
	if( fp == NULL )
		throw RageException( "Error opening song file '%s' for writing.", sPath );

	fprintf( fp, "#TITLE:%s;\n", m_sMainTitle );
	fprintf( fp, "#SUBTITLE:%s;\n", m_sSubTitle );
	fprintf( fp, "#ARTIST:%s;\n", m_sArtist );
	fprintf( fp, "#CREDIT:%s;\n", m_sCredit );
	fprintf( fp, "#BANNER:%s;\n", m_sBannerFile );
	fprintf( fp, "#BACKGROUND:%s;\n", m_sBackgroundFile );
	fprintf( fp, "#CDTITLE:%s;\n", m_sCDTitleFile );
	fprintf( fp, "#MOVIEBACKGROUND:%s;\n", m_sMovieBackgroundFile );
	fprintf( fp, "#MUSIC:%s;\n", m_sMusicFile );
	fprintf( fp, "#MUSICBYTES:%u;\n", m_iMusicBytes );
	fprintf( fp, "#MUSICLENGTH:%.2f;\n", m_fMusicLengthSeconds );
	fprintf( fp, "#FIRSTBEAT:%.2f;\n", m_fFirstBeat );
	fprintf( fp, "#LASTBEAT:%.2f;\n", m_fLastBeat );
	fprintf( fp, "#OFFSET:%.2f;\n", m_fBeat0OffsetInSeconds );
	fprintf( fp, "#SAMPLESTART:%.2f;\n", m_fMusicSampleStartSeconds );
	fprintf( fp, "#SAMPLELENGTH:%.2f;\n", m_fMusicSampleLengthSeconds );

	fprintf( fp, "#BPMS:" );
	for( i=0; i<m_BPMSegments.GetSize(); i++ )
	{
		BPMSegment &bs = m_BPMSegments[i];

		fprintf( fp, "%.2f=%.2f", bs.m_fStartBeat, bs.m_fBPM );
		if( i != m_BPMSegments.GetSize()-1 )
			fprintf( fp, "," );
	}
	fprintf( fp, ";\n" );

	fprintf( fp, "#STOPS:" );
	for( i=0; i<m_StopSegments.GetSize(); i++ )
	{
		StopSegment &fs = m_StopSegments[i];

		fprintf( fp, "%.2f=%.2f", fs.m_fStartBeat, fs.m_fStopSeconds );
		if( i != m_StopSegments.GetSize()-1 )
			fprintf( fp, "," );
	}
	fprintf( fp, ";\n" );
	
	fprintf( fp, "#ANIMATIONS:" );
	for( i=0; i<m_AnimationSegments.GetSize(); i++ )
	{
		AnimationSegment &seg = m_AnimationSegments[i];

		fprintf( fp, "%.2f=%s", seg.m_fStartBeat, seg.m_sAnimationName );
		if( i != m_AnimationSegments.GetSize()-1 )
			fprintf( fp, "," );
	}
	fprintf( fp, ";\n" );
	
	//
	// Save all Notes for this file
	//
	for( i=0; i<m_apNotes.GetSize(); i++ ) 
		m_apNotes[i]->WriteSMNotesTag( fp );

	fclose( fp );
}

Grade Song::GetGradeForDifficultyClass( NotesType nt, DifficultyClass dc )
{
	CArray<Notes*, Notes*> aNotes;
	this->GetNotesThatMatch( nt, aNotes );
	SortNotesArrayByDifficulty( aNotes );

	for( int i=0; i<aNotes.GetSize(); i++ )
	{
		Notes* pNotes = aNotes[i];
		if( pNotes->m_DifficultyClass == dc )
			return pNotes->m_TopGrade;
	}
	return GRADE_NO_DATA;
}



/////////////////////////////////////
// Sorting
/////////////////////////////////////

int CompareSongPointersByTitle(const void *arg1, const void *arg2)
{
	Song* pSong1 = *(Song**)arg1;
	Song* pSong2 = *(Song**)arg2;
	
	CString sTitle1 = pSong1->GetFullTitle();
	CString sTitle2 = pSong2->GetFullTitle();

	CString sFilePath1 = pSong1->GetSongFilePath();		// this is unique among songs
	CString sFilePath2 = pSong2->GetSongFilePath();

	CString sCompareString1 = sTitle1 + sFilePath1;
	CString sCompareString2 = sTitle2 + sFilePath2;

	return CompareCStringsAsc( (void*)&sCompareString1, (void*)&sCompareString2 );
}

void SortSongPointerArrayByTitle( CArray<Song*, Song*> &arraySongPointers )
{
	qsort( arraySongPointers.GetData(), arraySongPointers.GetSize(), sizeof(Song*), CompareSongPointersByTitle );
}

int CompareSongPointersByBPM(const void *arg1, const void *arg2)
{
	Song* pSong1 = *(Song**)arg1;
	Song* pSong2 = *(Song**)arg2;
		
	float fMinBPM1, fMaxBPM1, fMinBPM2, fMaxBPM2;
	pSong1->GetMinMaxBPM( fMinBPM1, fMaxBPM1 );
	pSong2->GetMinMaxBPM( fMinBPM2, fMaxBPM2 );

	CString sFilePath1 = pSong1->GetSongFilePath();		// this is unique among songs
	CString sFilePath2 = pSong2->GetSongFilePath();

	if( fMaxBPM1 < fMaxBPM2 )
		return -1;
	else if( fMaxBPM1 == fMaxBPM2 )
		return CompareCStringsAsc( (void*)&sFilePath1, (void*)&sFilePath2 );
	else
		return 1;
}

void SortSongPointerArrayByBPM( CArray<Song*, Song*> &arraySongPointers )
{
	qsort( arraySongPointers.GetData(), arraySongPointers.GetSize(), sizeof(Song*), CompareSongPointersByBPM );
}


int CompareSongPointersByArtist(const void *arg1, const void *arg2)
{
	Song* pSong1 = *(Song**)arg1;
	Song* pSong2 = *(Song**)arg2;
		
	CString sArtist1 = pSong1->m_sArtist;
	CString sArtist2 = pSong2->m_sArtist;

	if( sArtist1 < sArtist2 )
		return -1;
	else if( sArtist1 == sArtist2 )
		return CompareSongPointersByTitle( arg1, arg2 );
	else
		return 1;
}

void SortSongPointerArrayByArtist( CArray<Song*, Song*> &arraySongPointers )
{
	qsort( arraySongPointers.GetData(), arraySongPointers.GetSize(), sizeof(Song*), CompareSongPointersByArtist );
}

int CompareSongPointersByGroup(const void *arg1, const void *arg2)
{
	Song* pSong1 = *(Song**)arg1;
	Song* pSong2 = *(Song**)arg2;
		
	CString sGroup1 = pSong1->m_sGroupName;
	CString sGroup2 = pSong2->m_sGroupName;

	if( sGroup1 < sGroup2 )
		return -1;
	else if( sGroup1 == sGroup2 )
		return CompareSongPointersByTitle( arg1, arg2 );
	else
		return 1;
}

void SortSongPointerArrayByGroup( CArray<Song*, Song*> &arraySongPointers )
{
	qsort( arraySongPointers.GetData(), arraySongPointers.GetSize(), sizeof(Song*), CompareSongPointersByGroup );
}

int CompareSongPointersByMostPlayed(const void *arg1, const void *arg2)
{
	Song* pSong1 = *(Song**)arg1;
	Song* pSong2 = *(Song**)arg2;
		
	int iNumTimesPlayed1 = pSong1->GetNumTimesPlayed();
	int iNumTimesPlayed2 = pSong2->GetNumTimesPlayed();

	if( iNumTimesPlayed1 < iNumTimesPlayed2 )
		return -1;
	else if( iNumTimesPlayed1 == iNumTimesPlayed2 )
		return CompareSongPointersByTitle( arg1, arg2 );
	else
		return 1;
}

void SortSongPointerArrayByMostPlayed( CArray<Song*, Song*> &arraySongPointers )
{
	qsort( arraySongPointers.GetData(), arraySongPointers.GetSize(), sizeof(Song*), CompareSongPointersByMostPlayed );
}