www.pudn.com > VirtualVCR-src-v2.6.9.zip > CAppPropData.cpp

/* 
	Virtual VCR 
    Copyright (C) 2002  Shaun Faulds 
 
    This program is free software; you can redistribute it and/or modify 
    it under the terms of the GNU General Public License as published by 
    the Free Software Foundation; either version 2 of the License, or 
    (at your option) any later version. 
 
    This program is distributed in the hope that it will be useful, 
    but WITHOUT ANY WARRANTY; without even the implied warranty of 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    GNU General Public License for more details. 
 
    You should have received a copy of the GNU General Public License 
    along with this program; if not, write to the Free Software 
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
 
	Acknowledgments: 
	This application and associated filters are based on the examples 
	from the Microsoft DirectX DirectShow SDK. 
*/ 
 
#include "CAppPropData.h" 
#include "CTVstation.h" 
 
 
CAppPropData::CAppPropData() 
{ 
 
	// Get the application path info and 
	// and set the application INI file name 
 
	LPSTR pathInfo = new char[_MAX_PATH+1];  
	 
	GetCurrentDirectory(_MAX_PATH, pathInfo); 
 
	INIfile = new char[_MAX_PATH]; 
	wsprintf(INIfile, TEXT("%s\\%s"), pathInfo, "VirtualVCR.ini"); 
 
	FilterNamesfile = new char[_MAX_PATH]; 
	wsprintf(FilterNamesfile, TEXT("%s\\%s"), pathInfo, "FilterNames.ini"); 
 
	delete[] pathInfo; 
 
	// Do not use Pre filtering by default 
	UsePreFilters = false; 
 
	filterList = new CFilterList(); 
	reloadSelectedFilters("INIT", true); 
 
	appendStampToName = false; 
 
	VideoCodec = new CCodec(CLSID_VideoCompressorCategory); 
	AudioCodec = new CCodec(CLSID_AudioCompressorCategory); 
 
	memset(channels, 0, sizeof(channels[0]) * 256); 
} 
 
CAppPropData::~CAppPropData() 
{ 
	delete VideoCodec; 
	delete AudioCodec; 
	delete []INIfile; 
	delete filterList; 
 
	deleteChannelData(); 
} 
 
// Save the session data, this data is saved each time the app is closed 
BOOL CAppPropData::saveSessionData() 
{ 
	TCHAR *tach = new TCHAR [1024]; 
 
	wsprintf(tach, TEXT("%d"), iCaptureStatsWindowX); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CapStatX"), tach, INIfile); 
 
	wsprintf(tach, TEXT("%d"), iCaptureStatsWindowY); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CapStatY"), tach, INIfile); 
 
	wsprintf(tach, TEXT("%d"), iApplicationWindowX); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AppLocX"), tach, INIfile); 
 
	wsprintf(tach, TEXT("%d"), iApplicationWindowY); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AppLocY"), tach, INIfile); 
 
	return true; 
} 
 
// Saves the settings to the INI file, this is used for "store defaults" 
// and also save profile. 
BOOL CAppPropData::savePersistentData(LPSTR newFileName, bool defaultINI) 
{ 
	LPSTR destination = INIfile; 
	if(!defaultINI) 
		destination = newFileName; 
 
	TCHAR *tach = new TCHAR [1024]; 
 
	wsprintf(tach, TEXT("%d"), (int)(audioInputLevel * 1000)); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioInputLevel"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), SaveCapStats); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("SaveCapStats"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), AlwaysOnTop); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AlwaysOnTop"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), HideBars); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("HideBars"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), audioInputIndex); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioInputIndex"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), (int)(ResampleAudioTo * 100000)); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("ResampleAudioTo"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), audioResampleType); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioResampleType"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), streamOffsetType); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("StreamOffsetType"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Brit); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoBrightness"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Hue); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoHue"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Cont); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoContrast"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Sat); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoSaturation"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Colour); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoColour"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Gamma); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoGamma"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Video_Sharp); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoSharpness"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), TunerChannel); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("TunerChannel"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), tunerCountryCode); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("TunerCountry"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), tunerInputType); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("TunerInputType"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), tunerMode); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("TunerMode"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), AudioDelay); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioDelay"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), ShowAudioScope); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("ShowAudioScope"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), ShowHistogram); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("ShowHistogram"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), LogAVdiff); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("LogAVdiff"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), UseSmartTee); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("UseSmartTee"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), CapStatsRelativePos); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CapStatRelative"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), fWantCaptureStats); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("WantCaptureStats"), tach, destination); 
 
	// store show on stop settings 
    wsprintf(tach, TEXT("%d"), showStatsOnStop); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("ShowOnStop"), tach, destination); 
 
	// store AVI compat index 
    wsprintf(tach, TEXT("%d"), compatAVIindex); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AVIcompatINDEX"), tach, destination); 
 
	// store av sync settings 
    wsprintf(tach, TEXT("%d"), useAudioResample); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("UseAudioResample"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), SyncUsingStreamOffset); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("SyncUsingStreamOffset"), tach, destination); 
 
    // store current settings 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CaptureFile"), szCaptureFile, destination); 
 
	// Write the colour format out to the prop file 
	ColourFormatName(ColourFormat, tach); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoColourFormat"), tach, destination); 
 
	// Write all the other settings out 
    wsprintf(tach, TEXT("%d"), fWantPreview); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("WantPreview"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), (int)(10000000 / FrameRate)); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("FrameRate"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), fUseCustomFormat); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("UseFrameRate"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), fCapAudio); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CaptureAudio"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), iMasterStream); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("MasterStream"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), fUseTimeLimit); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("UseTimeLimit"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), dwTimeLimit); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("TimeLimit"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), CustomWidth); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CustomWidth"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), CustomHeight); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CustomHeight"), tach, destination); 
 
    wsprintf(tach, TEXT("%s"), VideoCodec->getCodecIDstring(VideoCodec->currentCodecINDEX()).c_str()); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoCompCodec"), tach, destination); 
 
    wsprintf(tach, TEXT("%s"), AudioCodec->getCodecIDstring(AudioCodec->currentCodecINDEX()).c_str()); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioCompCodec"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), CompressVideo); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CompressVideo"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), CompressAudio); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("CompressAudio"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), Audio_Capability_Index); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioCapabilityIndex"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), dwFreeSpaceLimit); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("FreeSpaceLimit"), tach, destination); 
 
    wsprintf(tach, TEXT("%d"), fUseFreeSpace); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("UseFreeSpace"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), iVideoInputIndex); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoInputIndex"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), UsePreFilters); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("UsePreFilters"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), appendStampToName); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AppendStampToName"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Audio_nChannel); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("Audio_nChannel"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Audio_nSamplesPerSec); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("Audio_nSamplesPerSec"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Audio_nAvgBytesPerSec); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("Audio_nAvgBytesPerSec"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Audio_nBlockAlign); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("Audio_nBlockAlign"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Audio_wBitsPerSample); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("Audio_wBitsPerSample"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), Audio_wFormatTag); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("Audio_wFormatTag"), tach, destination); 
 
	// Write out the filter list to the INI file 
	TCHAR *filterName = new TCHAR[1024]; 
	int filterNumber = 0; 
	while(filterList->getFilterPointer(filterNumber)) 
	{	 
		wsprintf(filterName, TEXT("FILTER%d"), filterNumber); 
		string filterID = filterList->getIDstring(filterNumber); 
		wsprintf(tach, TEXT("%s=%s"), filterID.c_str(), filterList->getFilterPropertyString(filterNumber)); 
	    WritePrivateProfileString(TEXT("Filters"), filterName, tach, destination); 
		filterNumber++; 
	} 
	wsprintf(filterName, TEXT("FILTER%d"), filterNumber); 
	WritePrivateProfileString(TEXT("Filters"), filterName, "end", destination); 
	delete []filterName; 
 
	// Save the current device 
	wsprintf(tach, TEXT("%d"), VideoDeviceIndex); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoDevice"), tach, destination); 
 
	wsprintf(tach, TEXT("%d"), AudioDeviceIndex); 
	WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioDevice"), tach, destination); 
 
	// Save close on stop time reached 
    wsprintf(tach, TEXT("%d"), fQuitWhenDone); 
    WritePrivateProfileString(TEXT("VirtualVCR"), TEXT("QuitWhenDone"), tach, destination); 
 
	// Save Channel info 
	saveChannelInfo(destination); 
 
	return true; 
} 
 
int CAppPropData::loadChannelInfo(LPSTR sourceFile) 
{ 
	deleteChannelData(); 
 
	for(int x = 0; x < 256; x++) 
	{ 
		channels[0] = NULL; 
	} 
/* 
	channels[0] = new CTVstation(); 
	channels[0]->setChannel(9); 
	channels[0]->setChannelMAP(7); 
	channels[0]->setChannelName("Channel 7"); 
 
	channels[1] = new CTVstation(); 
	channels[1]->setChannel(11); 
	channels[1]->setChannelMAP(9); 
	channels[1]->setChannelName("Channel 9"); 
 
	channels[2] = new CTVstation(); 
	channels[2]->setChannel(12); 
	channels[2]->setChannelMAP(10); 
	channels[2]->setChannelName("Channel 10"); 
*/ 
 
	TCHAR channelData[64]; 
	int channel = -1; 
	int channelMAP = -1; 
	char channelName[256]; 
	 
	for(int y = 0; y < 256; y++) 
	{ 
		wsprintf(channelData, TEXT("%d-ID"), y); 
		channel = GetPrivateProfileInt(TEXT("ChannelINFO"), channelData, -1, sourceFile); 
		if(channel > -1) 
		{ 
			wsprintf(channelData, TEXT("%d-MAP"), y); 
			channelMAP = GetPrivateProfileInt(TEXT("ChannelINFO"), channelData, -1, sourceFile); 
 
			wsprintf(channelData, TEXT("%d-NAME"), y); 
		    GetPrivateProfileString(TEXT("ChannelINFO"), channelData, TEXT(""), 
				channelName, sizeof(channelName), sourceFile); 
			 
			channels[y] = new CTVstation(); 
			channels[y]->setChannel(channel); 
			channels[y]->setChannelMAP(channelMAP); 
			channels[y]->setChannelName(channelName); 
 
		} 
		else 
			break; 
 
	} 
 
	return 0; 
} 
 
int CAppPropData::saveChannelInfo(LPSTR destinationFile) 
{ 
	TCHAR tach[256]; 
	TCHAR channelData[64]; 
	const char *name = NULL; 
 
	for(int x = 0; x < 256; x++) 
	{ 
		if(channels[x] != NULL) 
		{ 
			wsprintf(channelData, TEXT("%d-ID"), x); 
			wsprintf(tach, TEXT("%d"), channels[x]->getChannel()); 
			WritePrivateProfileString(TEXT("ChannelINFO"), channelData, tach, destinationFile); 
 
			wsprintf(channelData, TEXT("%d-MAP"), x); 
			wsprintf(tach, TEXT("%d"), channels[x]->getChannelMAP()); 
			WritePrivateProfileString(TEXT("ChannelINFO"), channelData, tach, destinationFile); 
 
			wsprintf(channelData, TEXT("%d-NAME"), x); 
			name = channels[x]->getChannelName(); 
			wsprintf(tach, TEXT("%s"), name); 
			WritePrivateProfileString(TEXT("ChannelINFO"), channelData, tach, destinationFile); 
		} 
		else 
		{ 
			wsprintf(channelData, TEXT("%d-ID"), x); 
			wsprintf(tach, TEXT("%d"), -1); 
			WritePrivateProfileString(TEXT("ChannelINFO"), channelData, tach, destinationFile); 
 
			wsprintf(channelData, TEXT("%d-MAP"), x); 
			wsprintf(tach, TEXT("%d"), -1); 
			WritePrivateProfileString(TEXT("ChannelINFO"), channelData, tach, destinationFile); 
 
			wsprintf(channelData, TEXT("%d-NAME"), x); 
			wsprintf(tach, TEXT("%s"), "none"); 
			WritePrivateProfileString(TEXT("ChannelINFO"), channelData, tach, destinationFile); 
 
			break; 
		} 
	} 
 
	return 0; 
} 
 
int CAppPropData::deleteChannelData() 
{ 
 
	for(int x = 0; x < 256; x++) 
	{ 
		if(channels[x] != NULL) 
		{ 
			delete channels[x]; 
			channels[x] = NULL; 
		} 
	} 
 
	return 0; 
} 
 
BOOL CAppPropData::loadData() 
{ 
 
	return loadProfileData(INIfile, true); 
 
} 
 
BOOL CAppPropData::loadProfileData(LPSTR newFileName, BOOL loadAll) 
{ 
	// load capture stats relative pos settings 
	// try to load the first settings, if it dows not exist 
	// then fail as this settings should be available and 
	// if it is not then the file does not exist 
	// valid valuse for CapStatRelative are 0 or 1 so -1 
	// means that the file did not exist, is this is the case 
	// return false, else set the rest of the settings 
 
	int capTest = -1; 
	try 
	{ 
		capTest = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CapStatRelative"), -1, newFileName);  
		if(capTest == -1 && loadAll == false) 
			return false; 
	} 
	catch(...) 
	{ 
		return false; 
	} 
 
	if(capTest == -1) 
		CapStatsRelativePos = 0; 
	else 
		CapStatsRelativePos = capTest; 
 
	// Now load the rest of the settings 
 
	audioInputLevel =  
		(double)GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AudioInputLevel"), 200, newFileName)  / 1000; 
	audioInputIndex =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AudioInputIndex"), -1, newFileName); 
 
	Video_Brit =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoBrightness"), -1, newFileName); 
	Video_Hue = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoHue"), -1, newFileName); 
	Video_Cont = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoContrast"), -1, newFileName); 
	Video_Sat = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoSaturation"), -1, newFileName); 
	Video_Colour = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoColour"), 1, newFileName); 
	Video_Gamma = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoGamma"), -1, newFileName); 
	Video_Sharp = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoSharpness"), -1, newFileName); 
 
	AlwaysOnTop =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AlwaysOnTop"), 0, newFileName); 
 
	SaveCapStats =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("SaveCapStats"), 0, newFileName); 
 
	HideBars =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("HideBars"), 0, newFileName); 
 
	ResampleAudioTo =  
		(double)GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("ResampleAudioTo"), 10000000, newFileName) / 100000;		 
 
	AudioDelay = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AudioDelay"), 0, newFileName); 
 
	ShowAudioScope = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("ShowAudioScope"), 0, newFileName); 
 
	ShowHistogram =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("ShowHistogram"), 0, newFileName); 
 
	audioResampleType =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AudioResampleType"), 0, newFileName); 
 
	streamOffsetType =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("StreamOffsetType"), 0, newFileName); 
 
	// Log the av diff settings 
	LogAVdiff = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("LogAVdiff"), 0, newFileName); 
 
	//Tuner Mode NTSC PAL etc 
	tunerMode = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("TunerMode"), 0, newFileName); 
 
	//Use Smart Tee to preview 
	UseSmartTee = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("UseSmartTee"), 0, newFileName); 
 
	//AVI compatibility index 
	compatAVIindex = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AVIcompatINDEX"), 0, newFileName); 
 
	// Show Stats on stop 
	showStatsOnStop = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("ShowOnStop"), 0, newFileName);  
 
    // do we want captur stats? 
    fWantCaptureStats = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("WantCaptureStats"), FALSE, newFileName); 
 
	// load audio sync settings 
	useAudioResample = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("UseAudioResample"), 0, newFileName); 
	SyncUsingStreamOffset = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("SyncUsingStreamOffset"), 0, newFileName); 
 
	// load Audio settings 
	Audio_nChannel = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("Audio_nChannel"), 2, newFileName); 
	Audio_nSamplesPerSec = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("Audio_nSamplesPerSec"), 44100, newFileName); 
	Audio_nAvgBytesPerSec = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("Audio_nAvgBytesPerSec"), 176400, newFileName); 
	Audio_nBlockAlign = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("Audio_nBlockAlign"), 4, newFileName); 
	Audio_wBitsPerSample = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("Audio_wBitsPerSample"), 16, newFileName); 
	Audio_wFormatTag = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("Audio_wFormatTag"), 1, newFileName); 
 
    // do we want preview? 
    fWantPreview = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("WantPreview"), FALSE, newFileName); 
 
    // get the video compressor name 
	char videoComp[1024]; 
    GetPrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoCompCodec"), TEXT("none"), 
        videoComp, sizeof(videoComp), newFileName); 
	VideoCodec->getFilterByID(videoComp); 
 
	// get the audio compression codec name 
	char audioComp[1024]; 
    GetPrivateProfileString(TEXT("VirtualVCR"), TEXT("AudioCompCodec"), TEXT("none"), 
        audioComp, sizeof(audioComp), newFileName); 
	AudioCodec->getFilterByID(audioComp); 
	 
	Audio_Capability_Index =  
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AudioCapabilityIndex"), -1, newFileName); 
 
	CompressAudio = 
		GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CompressAudio"), 0, newFileName); 
 
    // do we want audio? 
    fCapAudio = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CaptureAudio"), TRUE, newFileName); 
 
	// Set the use Pre Filters Setting 
	UsePreFilters = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("UsePreFilters"), FALSE, newFileName); 
 
	// do we want video compression 
	CompressVideo = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CompressVideo"), FALSE, newFileName); 
 
 	iMasterStream = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("MasterStream"), -1, newFileName); 
 
    // get the frame rate from win.ini before making the graph 
    fUseCustomFormat = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("UseFrameRate"), 0, newFileName); 
    int units_per_frame = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("FrameRate"), 400000, newFileName);  // 15fps 
    FrameRate = 10000000. / units_per_frame; 
    FrameRate = (int)(FrameRate * 100) / 100.; 
    if(FrameRate <= 0.) 
        FrameRate = 25.0; 
 
	// get custom size settings 
    CustomWidth = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CustomWidth"), 320, newFileName); 
	CustomHeight = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CustomHeight"), 240, newFileName); 
 
	// Get the colour format setting 
	TCHAR colourFormat[128]; 
	GetPrivateProfileString(TEXT("VirtualVCR"), TEXT("VideoColourFormat"), TEXT("RGB24"), 
		colourFormat, sizeof(colourFormat), newFileName); 
	ColourFormat = ColourFormatGUID(colourFormat); 
 
	// Get the video input Index of the Crossbar 
	iVideoInputIndex = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoInputIndex"), -1, newFileName); 
 
	// get time time limit stuff 
    fQuitWhenDone = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("QuitWhenDone"), 0, newFileName); 
    fUseTimeLimit = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("UseTimeLimit"), 0, newFileName); 
	fUseFreeSpace = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("UseFreeSpace"), 0, newFileName); 
    dwTimeLimit = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("TimeLimit"), 0, newFileName); 
	dwFreeSpaceLimit = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("FreeSpaceLimit"), 0, newFileName); 
 
    // get the capture file name 
	GetPrivateProfileString(TEXT("VirtualVCR"), TEXT("CaptureFile"), TEXT("capture.avi"), 
		szCaptureFile, sizeof(szCaptureFile), newFileName); 
 
	// Get use time data stamp info 
    appendStampToName = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AppendStampToName"), 0, newFileName); 
 
	// Get the device names to use 
	VideoDeviceIndex = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("VideoDevice"), 0, newFileName); 
	AudioDeviceIndex = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AudioDevice"), 0, newFileName); 
 
 
	// Get Tuner input type 
	tunerInputType  = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("TunerInputType"), 61, newFileName);  
 
	// Get Tuner Country code 
	tunerCountryCode = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("TunerCountry"), 61, newFileName);  
 
	// Get Last TV Channel 
	TunerChannel = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("TunerChannel"), 2, newFileName);  
 
	// If this is the first load then we need to load all 
	// the data in. 
	if(loadAll) 
	{ 
		// get Cature StatsWinod location 
		iCaptureStatsWindowX = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CapStatX"), 50, newFileName); 
		iCaptureStatsWindowY = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("CapStatY"), 50, newFileName); 
 
		// get application start xy 
		iApplicationWindowX = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AppLocX"), 50, newFileName); 
		iApplicationWindowY = GetPrivateProfileInt(TEXT("VirtualVCR"), TEXT("AppLocY"), 50, newFileName); 
	} 
 
 
	reloadSelectedFilters(newFileName, false); 
 
	loadChannelInfo(newFileName); 
 
	return true; 
} 
 
BOOL CAppPropData::reloadSelectedFilters(LPSTR newFileName, bool defaultINI) 
{ 
	filterList->removeAllFilterFromSelected(); 
 
	LPSTR source = INIfile; 
	if(!defaultINI) 
		source = newFileName; 
 
	TCHAR data[1024]; 
	TCHAR *filterName = new TCHAR[1024]; 
	int filterNumber = 0; 
 
	while(true) 
	{ 
 
		wsprintf(filterName, TEXT("FILTER%d"), filterNumber); 
		GetPrivateProfileString(TEXT("Filters"), filterName, TEXT("end"), data, sizeof(data), source); 
 
		if(!strcmp(data, "end")) 
			break; 
 
		char *pch; 
		char *guidFilter; 
		char *prop; 
		pch = strtok (data,"="); 
		int type = 0; 
		while (pch != NULL) 
		{ 
			if(type == 0) 
				guidFilter = pch; 
			if(type == 1) 
				prop = pch; 
			type++; 
			pch = strtok (NULL, "="); 
		} 
		filterList->selectFilterByIDString(guidFilter, prop); 
 
		filterNumber++; 
	} 
	delete []filterName; 
 
	return true; 
} 
 
 
void CAppPropData::ColourFormatName(GUID guid, TCHAR *name) 
{ 
	if(MEDIASUBTYPE_YVU9 == guid) 
		wsprintf(name, "YVU9"); 
 
	else if(MEDIASUBTYPE_Y411 == guid) 
		wsprintf(name, "Y411"); 
 
	else if(MEDIASUBTYPE_Y41P == guid) 
		wsprintf(name, "Y41P"); 
 
	else if(MEDIASUBTYPE_YUY2 == guid) 
		wsprintf(name, "YUY2"); 
 
	else if(MEDIASUBTYPE_YVYU == guid) 
		wsprintf(name, "YVYU"); 
 
	else if(MEDIASUBTYPE_UYVY == guid) 
		wsprintf(name, "UYVY"); 
 
	else if(MEDIASUBTYPE_Y211 == guid) 
		wsprintf(name, "Y211"); 
 
	else if(MEDIASUBTYPE_RGB4 == guid) 
		wsprintf(name, "RGB4"); 
 
	else if(MEDIASUBTYPE_RGB8 == guid) 
		wsprintf(name, "RGB8"); 
 
	else if(MEDIASUBTYPE_RGB565 == guid) 
		wsprintf(name, "RGB565"); 
 
	else if(MEDIASUBTYPE_RGB555 == guid) 
		wsprintf(name, "RGB555"); 
 
	else if(MEDIASUBTYPE_RGB24 == guid) 
		wsprintf(name, "RGB24"); 
 
	else if(MEDIASUBTYPE_RGB32 == guid) 
		wsprintf(name, "RGB32"); 
 
	else if(MEDIASUBTYPE_ARGB32 == guid) 
		wsprintf(name, "ARGB32"); 
 
	else if(MEDIASUBTYPE_YV12 == guid) 
		wsprintf(name, "YV12"); 
 
	else if(MEDIASUBTYPE_IF09 == guid) 
		wsprintf(name, "IF09"); 
 
	else if(MEDIASUBTYPE_IYUV == guid) 
		wsprintf(name, "IYUV"); 
 
	else 
		wsprintf(name, "????"); 
} 
 
GUID CAppPropData::ColourFormatGUID(TCHAR *name) 
{ 
	if(strcmp(name, "YVU9") == 0) 
		return (GUID)MEDIASUBTYPE_YVU9; 
 
	else if(strcmp(name, "Y411") == 0) 
		return (GUID)MEDIASUBTYPE_Y411; 
 
	else if(strcmp(name, "Y41P") == 0) 
		return (GUID)MEDIASUBTYPE_Y41P; 
 
	else if(strcmp(name, "YUY2") == 0) 
		return (GUID)MEDIASUBTYPE_YUY2; 
 
	else if(strcmp(name, "YVYU") == 0) 
		return (GUID)MEDIASUBTYPE_YVYU; 
 
	else if(strcmp(name, "UYVY") == 0) 
		return (GUID)MEDIASUBTYPE_UYVY; 
 
	else if(strcmp(name, "Y211") == 0) 
		return (GUID)MEDIASUBTYPE_Y211; 
 
	else if(strcmp(name, "RGB4") == 0) 
		return (GUID)MEDIASUBTYPE_RGB4; 
 
	else if(strcmp(name, "RGB8") == 0) 
		return (GUID)MEDIASUBTYPE_RGB8; 
 
	else if(strcmp(name, "RGB565") == 0)		 
		return (GUID)MEDIASUBTYPE_RGB565; 
 
	else if(strcmp(name, "RGB555") == 0) 
		return (GUID)MEDIASUBTYPE_RGB555; 
 
	else if(strcmp(name, "RGB24") == 0) 
		return (GUID)MEDIASUBTYPE_RGB24; 
 
	else if(strcmp(name, "RGB32") == 0) 
		return (GUID)MEDIASUBTYPE_RGB32; 
 
	else if(strcmp(name, "ARGB32") == 0) 
		return (GUID)MEDIASUBTYPE_ARGB32; 
 
	else if(strcmp(name, "YV12") == 0) 
		return (GUID)MEDIASUBTYPE_YV12; 
	 
	else if(strcmp(name, "IF09") == 0) 
		return (GUID)MEDIASUBTYPE_IF09; 
 
	else if(strcmp(name, "IYUV") == 0) 
		return (GUID)MEDIASUBTYPE_IYUV; 
 
	else 
		return (GUID)MEDIASUBTYPE_RGB24; 
}