databurn.cpp

使用Windows IMAPI编写的光盘刻录程序

#include "StdAfx.h"
#include ".\databurn.h"
#include "DataBurn.h"
#include <stdio.h>
#include <windows.h>
#include <ole2.h>

extern VOID PASCAL EXPORT GetRecordDriLetter(CHAR* chrDriLet);

CDataBurn::CDataBurn(void)
{
	CoInitialize(NULL);	
	hr = CoCreateInstance(__uuidof(MSDiscMasterObj),
		                  NULL,CLSCTX_LOCAL_SERVER,
						  IID_IDiscMaster,
						  (void**)&pDiscMaster);
	hr = pDiscMaster->Open();
	hr = pDiscMaster->SetActiveDiscMasterFormat(IID_IJolietDiscMaster,(void**)&pJoliet);
	hr = pDiscMaster->EnumDiscRecorders(&recordersEnum); 
	hr = recordersEnum->Next(1,&pRecorder,&num);
	if(hr == S_OK)
	{
		byte pbsessions;
		byte pblasttrack; 
		ULONG ulstartaddress;
		ULONG ulnextwritable; 
		ULONG ulfreeblocks; 
		AvailRecorder = TRUE;	

     	hr = pRecorder->OpenExclusive();
		hr = pRecorder->QueryMediaInfo(&pbsessions,&pblasttrack,&ulstartaddress,&ulnextwritable,&ulfreeblocks);
		if(hr != S_OK)
		{
			AvailDisc = FALSE;
			DiscSpace = 0;
		}
		else
		{
			AvailDisc = TRUE;
			DiscSpace = ulfreeblocks/512;
		}
		hr = pRecorder->Close();
	}
	else
	{		
		AvailRecorder = FALSE;
	}
	hr = pDiscMaster->SetActiveDiscRecorder(pRecorder);

	pwcsName = new WCHAR;
	buffer = new char[8*1024*1024];
	IndexPath = "";
	IndexLi = 0;
	Progress = 0;
	bufferSize = 8*1024*1024;
	readSize = 0;
	writtenSize = 0;
	FileSize = 0;
	TempSize = 0;
	LimitSize = 100*1024*1024;//1073741824;	
	TotalFilesSize = 0;
	AddedFilesSize = 0;	
}

CDataBurn::~CDataBurn(void)
{
	delete []buffer;
	hr = recordersEnum->Release();
	if(pRecorder)
	{
		hr = pRecorder->Release();
	}
	hr = pJoliet->Release();
	hr = pDiscMaster->Close();
	hr = pDiscMaster->Release();
	CoUninitialize();
}

HRESULT CDataBurn::CDBurn(CString* FileList,CString* FolderList,CString* DeleteList,CString* AddedList,CProgressCtrl* ImageProgress)
{
	USES_CONVERSION;
	HANDLE hFind = NULL;
	WIN32_FIND_DATA FindFile;
	UINT Counter = 0;
	AddedFilesSize = 0;
	Progress = 0;
	TempSize = 0;

	TotalSize(FileList,FolderList,DeleteList,AddedList);
	hr = pDiscMaster->SetActiveDiscRecorder(pRecorder);
	hr = StgCreateStorageEx(NULL,
		                    STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE|STGM_DELETEONRELEASE,
						    STGFMT_STORAGE,
						    0,NULL,NULL,
						    IID_IStorage,
							reinterpret_cast<void**>(&pRootStorage)); 
	if(!SUCCEEDED(hr))
	{ 
		return E_FAIL;
	}	

	while(!FileList[Counter].IsEmpty())
	{
		CFile file(FileList[Counter],CFile::modeRead|CFile::shareExclusive);		
		pwcsName = A2W(file.GetFileName());
		FileSize = file.GetLength();	
		if((TempSize < LimitSize)||(TotalFilesSize-AddedFilesSize) < LimitSize)
		{
			AddedFilesSize = AddedFilesSize + FileSize;
			hr = pRootStorage->CreateStream(pwcsName,
				                            STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
										    NULL,NULL,&pStream);		
			readSize = file.Read(buffer,bufferSize);
			while(readSize>0)
			{
				pStream->Write(buffer,readSize,&writtenSize);
				TempSize = TempSize + readSize;
				Progress = Progress + int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
				ImageProgress->SetPos(Progress);
				Progress = Progress - int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
				readSize = file.Read(buffer,bufferSize);
			}
			file.Close();		
			pStream->Release();
			hr = pJoliet->AddData(pRootStorage,TRUE);
			hr = pRootStorage->DestroyElement(pwcsName);
		}
		else
		{
			hr = pDiscMaster->RecordDisc(FALSE,FALSE);			
			Progress = int((AddedFilesSize*1000+0.01)/(TotalFilesSize+0.01));
			file.Close();
			TempSize = 0;
			Counter--;
		//	hr = pDiscMaster->SetActiveDiscRecorder(pRecorder);	
		}
		Counter++;
	}		
	
	Counter = 0;
	while(!FolderList[Counter].IsEmpty())
	{
		hFind = FindFirstFile(FolderList[Counter],&FindFile);                 
		hr = pRootStorage->CreateStorage(A2W(FindFile.cFileName),
					                     STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
									     NULL,NULL,
									     &pStorage[IndexLi]);
		TreePath[IndexLi] = FindFile.cFileName;
		hr = AddFilesToStorage(FolderList[Counter],DeleteList,AddedList,ImageProgress);
		if(!SUCCEEDED(hr))
		{
			return E_FAIL;
		}
		Counter++;	
	}

	hr = pJoliet->AddData(pRootStorage,TRUE);
	hr = pDiscMaster->RecordDisc(FALSE,TRUE);
	hr = pRootStorage->Release();
	ImageProgress->SetPos(1000);
	MessageBox(NULL,"Burn Completed !","Burn Completed",0); 
	IndexLi = 0;
	TempSize = 0;
	AddedFilesSize = 0;
	return S_OK;
}

HRESULT CDataBurn::AddFilesToStorage(CString startPath,CString* DeleteList,CString* AddedList,CProgressCtrl* ImageProgress)
{
	USES_CONVERSION;
	HANDLE hFind = NULL;
	WIN32_FIND_DATA FindFile;	
	BOOL bLoop;
	CString FolderName;
	UINT count = 0;

    IndexLi++;	
	hFind = FindFirstFile(startPath,&FindFile);
	FolderName = FindFile.cFileName;
	if(IndexPath.IsEmpty())
	{
		IndexPath = FolderName;
	}
	else
	{
		IndexPath = IndexPath + "\\" + FolderName;
	}
    hFind = FindFirstFile(startPath + "\\*.*",&FindFile);
	if(hFind != INVALID_HANDLE_VALUE)
	{		
		bLoop = TRUE;
		while(bLoop) 
		{
			count = 0;
			BOOL bDelFlag = TRUE;
			CString TempString;
			TempString = startPath + "\\" +FindFile.cFileName;
			while(!DeleteList[count].IsEmpty()&&strcmp(TempString,DeleteList[count]) != 0)
			{
				count++;
			}
			if(!DeleteList[count].IsEmpty())
			{
				bDelFlag = FALSE;
			}	
			if((FindFile.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)&&strcmp(FindFile.cFileName,".") != 0&&strcmp(FindFile.cFileName,"..") != 0&&bDelFlag)
			{
				hr = pStorage[IndexLi-1]->CreateStorage(A2W(FindFile.cFileName),
					                                    STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
														NULL,NULL,
														&pStorage[IndexLi]);
				if(!SUCCEEDED(hr))
				{
					return E_FAIL;
				}
				TreePath[IndexLi] = FindFile.cFileName;				
				hr = AddFilesToStorage((startPath + "\\" +FindFile.cFileName),DeleteList,AddedList,ImageProgress);
				if(!SUCCEEDED(hr))
				{
					return E_FAIL;
				}		
			}			
			if((!(FindFile.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))&&strcmp(FindFile.cFileName,".") != 0&&strcmp(FindFile.cFileName,"..") != 0&&bDelFlag)
			{		
				CFile file(startPath + "\\" + FindFile.cFileName,CFile::modeRead|CFile::shareExclusive);
				pwcsName = A2W(file.GetFileName());
				FileSize = file.GetLength();		
				if((TempSize < LimitSize)||(TotalFilesSize-AddedFilesSize) < LimitSize)
				{
					AddedFilesSize = AddedFilesSize + FileSize;
					hr = pStorage[IndexLi-1]->CreateStream(pwcsName,
						                                   STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
														   NULL,NULL,&pStream);
					readSize = file.Read(buffer,bufferSize);
					while(readSize>0)
					{
						hr = pStream->Write(buffer,readSize,&writtenSize);
						TempSize = TempSize + readSize;
						Progress = Progress + int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						ImageProgress->SetPos(Progress);
						Progress = Progress - int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						readSize = file.Read(buffer,bufferSize);		
					}
					file.Close();
					hr = pStream->Release();
					hr = AddFilesToImage();				
				}
				else
				{
					hr = pDiscMaster->RecordDisc(FALSE,FALSE);					
					Progress = int((AddedFilesSize*1000+0.1)/(TotalFilesSize+0.1));
					ImageProgress->SetPos(Progress);
					TempSize = 0;
					hr = pDiscMaster->SetActiveDiscRecorder(pRecorder);

					AddedFilesSize = AddedFilesSize + FileSize;
					hr = pStorage[IndexLi-1]->CreateStream(pwcsName,
						                                   STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
														   NULL,NULL,&pStream);
					readSize = file.Read(buffer,bufferSize);
					while(readSize>0)
					{						
						pStream->Write(buffer,readSize,&writtenSize);
						TempSize = TempSize + readSize;
						Progress = Progress + int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						ImageProgress->SetPos(Progress);
						Progress = Progress - int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						readSize = file.Read(buffer,bufferSize);	
					}
					file.Close();
					hr = pStream->Release();
					hr = AddFilesToImage();
				}
			}	
			bLoop = FindNextFile(hFind,&FindFile);
		}
	}

	count = 0;
	while(!AddedList[count].IsEmpty())
	{
		if(strcmp(AddedList[count],IndexPath)==0)
		{
			hFind = FindFirstFile(AddedList[count+1],&FindFile);
			if(FindFile.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
			{
				hr = pStorage[IndexLi-1]->CreateStorage(A2W(FindFile.cFileName),
					                                    STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
														NULL,NULL,
														&pStorage[IndexLi]);
				if(!SUCCEEDED(hr))
				{
					return E_FAIL;
				}
				TreePath[IndexLi] = FindFile.cFileName;				
				hr = AddFilesToStorage(AddedList[count+1],DeleteList,AddedList,ImageProgress);
				if(!SUCCEEDED(hr))
				{
					return E_FAIL;
				}					
			}
			else
			{					
				CFile file(startPath + "\\" + FindFile.cFileName,CFile::modeRead|CFile::shareExclusive);
				pwcsName = A2W(file.GetFileName());
				FileSize = file.GetLength();		
				if((TempSize < LimitSize)||(TotalFilesSize-AddedFilesSize) < LimitSize)
				{
					AddedFilesSize = AddedFilesSize + FileSize;
					hr = pStorage[IndexLi-1]->CreateStream(pwcsName,
						                                   STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
														   NULL,NULL,&pStream);
					readSize = file.Read(buffer,bufferSize);
					while(readSize>0)
					{
						hr = pStream->Write(buffer,readSize,&writtenSize);
						TempSize = TempSize + readSize;
						Progress = Progress + int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						ImageProgress->SetPos(Progress);
						Progress = Progress - int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						readSize = file.Read(buffer,bufferSize);		
					}
					file.Close();
					hr = pStream->Release();
					hr = AddFilesToImage();				
				}
				else
				{
					hr = pDiscMaster->RecordDisc(FALSE,FALSE);					
					Progress = int((AddedFilesSize*1000+0.1)/(TotalFilesSize+0.1));
					ImageProgress->SetPos(Progress);
					TempSize = 0;
					hr = pDiscMaster->SetActiveDiscRecorder(pRecorder);

					AddedFilesSize = AddedFilesSize + FileSize;
					hr = pStorage[IndexLi-1]->CreateStream(pwcsName,
						                                   STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
														   NULL,NULL,&pStream);
					readSize = file.Read(buffer,bufferSize);
					while(readSize>0)
					{						
						pStream->Write(buffer,readSize,&writtenSize);
						TempSize = TempSize + readSize;
						Progress = Progress + int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						ImageProgress->SetPos(Progress);
						Progress = Progress - int(1000*(TempSize+0.001)/(2*TotalFilesSize + 0.001));
						readSize = file.Read(buffer,bufferSize);	
					}
					file.Close();
					hr = pStream->Release();
					hr = AddFilesToImage();
				}				
			}
		}
		count = count + 2;
	}

	IndexLi--;
	FindClose(hFind);
	hr = pStorage[IndexLi]->Release();
	TreePath[IndexLi] = "";
	IndexPath = IndexPath.Left(IndexPath.GetLength()-FolderName.GetLength()-1);
	return S_OK;
}

HRESULT CDataBurn::AddFilesToImage()
{
	USES_CONVERSION;
	pwcsName = A2W(TreePath[0]);
	for(int i = IndexLi-1;i>=0;i--)
	{
		hr = pStorage[i]->Release();
	}
	hr = pJoliet->AddData(pRootStorage,TRUE);
	hr = pRootStorage->DestroyElement(pwcsName);
	for(UINT i = 0;i < IndexLi;i++)
	{	
		pwcsName = A2W(TreePath[i]);
		if(i==0)
		{
			hr = pRootStorage->CreateStorage(pwcsName,
				                             STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
											 NULL,NULL,
											 &pStorage[i]);
		}
		else
		{
			hr = pStorage[i-1]->CreateStorage(pwcsName,
				                              STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,	
											  NULL,NULL,&pStorage[i]);
		}
	}
	return S_OK;
}

void CDataBurn::TotalSize(CString* FileList,CString* FolderList,CString* DeleteList,CString* AddedList)
{
	HANDLE hFind = NULL;
	WIN32_FIND_DATA fd; 	
	UINT Counter = 0;
	TotalFilesSize = 0;

	while(!FileList[Counter].IsEmpty())
	{
		hFind = FindFirstFile(FileList[Counter],&fd);
		if(hFind !=INVALID_HANDLE_VALUE)
		{
			TotalFilesSize = TotalFilesSize + fd.nFileSizeHigh*MAXDWORD + fd.nFileSizeLow;
			Counter++;
		}
	}
	if(Counter > 0)
	{
		FindClose(hFind);
	}
	Counter = 0;

	while(!FolderList[Counter].IsEmpty())
	{
		TotalFilesSize = TotalFilesSize + FolderSize(FolderList[Counter],DeleteList,AddedList);
		Counter++;
	}
}

ULONGLONG CDataBurn::FolderSize(CString Folder,CString* DeleteList,CString* AddedList)
{
	WIN32_FIND_DATA fd;
	HANDLE hFind = NULL;
	BOOL bLoop;
	ULONGLONG TotalFolderSize = 0;	
	CString FolderName;
	UINT count = 0;

	hFind = FindFirstFile(Folder,&fd);
	FolderName = fd.cFileName;
	if(IndexPath.IsEmpty())
	{
		IndexPath = fd.cFileName;
	}
	else
	{
		IndexPath = IndexPath + "\\" + fd.cFileName;
	}
    hFind = FindFirstFile(Folder + "\\*.*",&fd);
	if(hFind != INVALID_HANDLE_VALUE)
	{ 
		bLoop = TRUE;
		while(bLoop) 
		{
			count = 0;
			BOOL bDelFlag = TRUE;
			CString TempString = Folder + "\\" +fd.cFileName;
			while(!DeleteList[count].IsEmpty()&&(strcmp(DeleteList[count],IndexPath)!=0||strcmp(DeleteList[count+1],TempString)!=0))
			{
				count = count + 2;
			}
			if(!DeleteList[count].IsEmpty())
			{
				bDelFlag = FALSE;
			}	
			if((fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)&&strcmp(fd.cFileName,".") != 0&&strcmp(fd.cFileName,"..") != 0&&bDelFlag)
			{				
				TotalFolderSize = TotalFolderSize + FolderSize(Folder + "\\" +fd.cFileName,DeleteList,AddedList);			
			}			
			if((!(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))&&strcmp(fd.cFileName,".") != 0&&strcmp(fd.cFileName,"..") != 0&&bDelFlag)
			{
				TotalFolderSize = TotalFolderSize + fd.nFileSizeHigh*MAXDWORD + fd.nFileSizeLow;
			}		
			bLoop = FindNextFile(hFind,&fd);
		}
		FindClose(hFind);		
	}
	count = 0;

	while(!AddedList[count].IsEmpty())
	{
		if(strcmp(AddedList[count],IndexPath)==0)
		{
			hFind = FindFirstFile(AddedList[count+1],&fd);
			if(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
			{
				TotalFolderSize = TotalFolderSize + FolderSize(AddedList[count+1],DeleteList,AddedList);			
			}
			else
			{
				TotalFolderSize = TotalFolderSize + fd.nFileSizeHigh*MAXDWORD + fd.nFileSizeLow;
			}
		}
		count = count + 2;
	}

	IndexPath = IndexPath.Left(IndexPath.GetLength()-FolderName.GetLength()-1);
	return TotalFolderSize;	
}