////////////////////////////////////////////////////////////////
// MSDN Magazine -- April 2004
// If this code works, it was written by Paul DiLascia.
// If not, I don't know who wrote it.
// Compiles with Visual Studio .NET on Windows XP. Tab size=3.
//
#pragma once

#ifndef TRACE
#define TRACE ATLTRACE
#endif

#ifndef ASSERT
#define ASSERT ATLASSERT
#endif

class CDiscMaster;

#ifdef _DEBUG
#define TRACEHR(funcname,hr) \
	if (!SUCCEEDED(m_hr)) { TRACE(_T("*** %s returns %s\n"), \
		funcname, IMAPITools::GetErrorName(hr)); }
#else
#define TRACEHR __noop
#endif

//////////////////
// namespace for extern functions
//
namespace IMAPITools {
	extern LPCTSTR GetErrorName(HRESULT hr);
	extern LPCTSTR GetFormatName(const IID& iid);
	extern LPCTSTR GetRecorderTypeName(long type);
	extern LPCTSTR GetRecorderStateName(ULONG state);
	extern LPCTSTR GetMediaTypeName(long mtype);
	extern LPCTSTR GetMediaFlagsName(long mtype);
}

//////////////////
// Wrapper for shell interface ICDBurn.
//
class CCDBurn : public CComQIPtr<ICDBurn>
{
public:
	HRESULT m_hr;	// last error code

	CCDBurn() {
		m_hr = CoCreateInstance(CLSID_CDBurn,NULL,
			CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER);
		TRACEHR(_T("CoCreateInstance"),m_hr);
	}

	~CCDBurn() { }

	// Burn the data in staging area to CD
	//
	BOOL Burn(HWND hwnd) {
		m_hr = (*this)->Burn(hwnd);
		TRACEHR(_T("CCDBurn::Burn"),m_hr);
		return SUCCEEDED(m_hr);
	}

	// Does this machine have a recordable drive?
	//
	BOOL HasRecordableDrive() {
		BOOL bHasIt=FALSE;
		m_hr = (*this)->HasRecordableDrive(&bHasIt);
		TRACEHR(_T("CCDBurn::HasRecordableDrive"),m_hr);
		return (SUCCEEDED(m_hr) && bHasIt);
	}

	// Get drive letter for recordable CD drive, return as STL string.
	//
	CString GetRecorderDriveLetter() {
		WCHAR d[32]={0};
		m_hr = (*this)->GetRecorderDriveLetter(d, sizeof(d)/sizeof(d[0]));
		TRACEHR(_T("CCDBurn::GetRecorderDriveLetter"),m_hr);
		return d;
	}

	// Get location of burn (staging) area. You can change this by setting a
	// registry entry or using TWEAKUI in PowerToys for XP.
	// This is not an ICDBurn method, but useful anyway.
	//
	CString GetBurnFolderPath() {
		TCHAR path[MAX_PATH]={0};
		m_hr = SHGetSpecialFolderPath(NULL, path, CSIDL_CDBURN_AREA, FALSE);
		TRACEHR(_T("CCDBurn::GetBurnFolderPath"),m_hr);
		return path;
	}
};

//////////////////
// Handy struct for media info, instead of several bytes and longs
//
struct MEDIAINFO {
	BYTE  nSessions;
	BYTE  nLastTrack;
	ULONG nStartAddress;
	ULONG nNextWritable;
	ULONG nFreeBlocks;
};

//////////////////
// Handy struct for display names
//
struct DISPLAYNAMES {
	CString vendor;
	CString product;
	CString revision;
};

//////////////////
// Wrapper for IDiscRecorder, representing a recordable CD drive.
//
class CDiscRecorder : public CComQIPtr<IDiscRecorder>
{
public:
	HRESULT m_hr;

	CDiscRecorder() { }
	CDiscRecorder(CDiscMaster& dm);
	~CDiscRecorder() { Close(); }
	
	// Not really a GUID!
	CString GetRecorderGUID() {
		char temp[1024];
		ULONG cbRet;
		m_hr = (*this)->GetRecorderGUID((BYTE*)temp,sizeof(temp),&cbRet);
		TRACEHR(_T("CDiscRecorder::GetRecorderGUID"),m_hr);
		USES_CONVERSION;
		return temp;
	}

	long GetRecorderType() {
		long type=0;
		m_hr = (*this)->GetRecorderType(&type);
		TRACEHR(_T("CDiscRecorder::GetRecorderType"),m_hr);
		return type;
	}

	BOOL GetDisplayNames(DISPLAYNAMES& dn);

	CString GetBasePnPID()
	{
		CComBSTR b(256);
		m_hr = (*this)->GetBasePnPID(&b);
		TRACEHR(_T("CDiscRecorder::GetBasePnPID"),m_hr);
		return SUCCEEDED(m_hr) ? CString(b) : CString();
	}

	CString GetPath()
	{
		CComBSTR b(MAX_PATH);
		m_hr = (*this)->GetPath(&b);
		TRACEHR(_T("CDiscRecorder::GetPath"),m_hr);
 		return SUCCEEDED(m_hr) ? CString(b) : CString();
	}

	BOOL GetRecorderProperties(IPropertyStorage** pstg)
	{
		m_hr = (*this)->GetRecorderProperties(pstg);
		TRACEHR(_T("CDiscRecorder::GetRecorderProperties"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL SetRecorderProperties(IPropertyStorage* pstg)
	{
		m_hr = (*this)->SetRecorderProperties(pstg);
		TRACEHR(_T("CDiscRecorder::SetRecorderProperties"),m_hr);
		return SUCCEEDED(m_hr);
	}

	ULONG GetRecorderState()
	{
		ULONG state;
		m_hr = (*this)->GetRecorderState(&state);
		TRACEHR(_T("CDiscRecorder::GetRecorderState"),m_hr);
		return SUCCEEDED(m_hr) ? state : 0;
	}

	BOOL OpenExclusive()
	{
		m_hr = (*this)->OpenExclusive();
		TRACEHR(_T("CDiscRecorder::OpenExclusive"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL QueryMediaType(long& type, long& flags)
	{
		m_hr = (*this)->QueryMediaType(&type, &flags);
		TRACEHR(_T("CDiscRecorder::QueryMediaType"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL QueryMediaInfo(MEDIAINFO& mi)
	{
		m_hr = (*this)->QueryMediaInfo(&mi.nSessions,
			&mi.nLastTrack,
			&mi.nStartAddress,
			&mi.nNextWritable,
			&mi.nFreeBlocks);
		TRACEHR(_T("CDiscRecorder::QueryMediaInfo"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL Eject()
	{
		m_hr = (*this)->Eject();
		TRACEHR(_T("CDiscRecorder::Eject"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL Erase(BOOL bFullErase)
	{
		m_hr = (*this)->Erase(bFullErase);
		TRACEHR(_T("CDiscRecorder::Erase"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL Close()
	{
		m_hr = p ? (*this)->Close() : S_OK;
		return SUCCEEDED(m_hr);
	}
};

//////////////////
// Wrapper for IDiscMaster, the main IMAPI interface for a mastering session.
//
class CDiscMaster : public CComQIPtr<IDiscMaster>
{
public:
	HRESULT m_hr;

	CDiscMaster() {
		m_hr = CoCreateInstance(CLSID_MSDiscMasterObj,NULL,
			CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER);
		ASSERT(SUCCEEDED(m_hr));
	}
		
	~CDiscMaster() {
		Close();
	}

	// Open the recordable disc
	BOOL Open() {
		return m_hr = (*this)->Open(), SUCCEEDED(m_hr);
	}

	// Get supported formats as array instead of using IEnumXxx
	int GetSupportedFormats(IID* formats, int len);

	// Get/set current active format (data or audio)
	IID GetActiveDiscMasterFormat() {
		IID iid = IID_NULL;
		m_hr = (*this)->GetActiveDiscMasterFormat(&iid);
		TRACEHR(_T("CDiscRecorder::GetActiveDiscMasterFormat"),m_hr);
		return iid;
	}
	BOOL SetActiveDiscMasterFormat(IID& iid, void** pRecorder) {
		m_hr=(*this)->SetActiveDiscMasterFormat(iid,pRecorder);
		TRACEHR(_T("CDiscRecorder::SetActiveDiscMasterFormat"),m_hr);
		return SUCCEEDED(m_hr);
	}

	// Get/set active recorder
	BOOL GetActiveDiscRecorder(CDiscRecorder& recorder)
	{
		m_hr = (*this)->GetActiveDiscRecorder(&recorder);
		TRACEHR(_T("CDiscRecorder::GetActiveDiscRecorder"),m_hr);
		return SUCCEEDED(m_hr);
	}
	BOOL SetActiveDiscRecorder(CDiscRecorder& recorder)
	{
		m_hr = (*this)->SetActiveDiscRecorder(recorder);
		TRACEHR(_T("CDiscRecorder::SetActiveDiscRecorder"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL ClearFormatContent() {
		m_hr = (*this)->ClearFormatContent();
		TRACEHR(_T("CDiscRecorder::ClearFormatContent"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL RecordDisc(BOOL bSimulate=FALSE, BOOL bEjectAfterBurn=FALSE) {
		m_hr = (*this)->RecordDisc(bSimulate, bEjectAfterBurn);
		TRACEHR(_T("CDiscRecorder::RecordDisc"),m_hr);
		return SUCCEEDED(m_hr);
	}

	void Close() {
		m_hr = p ? (*this)->Close() : S_OK;
	}
};

//////////////////
// Handy class to enumerate disc recorders
//
class CDiscRecorderIterator : public CComQIPtr<IEnumDiscRecorders> 
{
public:
	HRESULT m_hr;

	CDiscRecorderIterator(CDiscMaster& dm) {
		HRESULT hr = dm->EnumDiscRecorders(&p);
		ASSERT(SUCCEEDED(hr));
	}

	BOOL Next(CDiscRecorder& dr) {
		ULONG nRet=0;
		dr.Release();
		return SUCCEEDED(m_hr=(*this)->Next(1, &dr.p, &nRet)) && nRet==1;
	}

	BOOL Reset() {
		return SUCCEEDED(m_hr = (*this)->Reset());
	}
};

//////////////////
// Wrapper for IJolietDiscMaster, interface for writing data
// (as oppposed to IRedbookDiscMaster, for audio).
//
class CJolietDiscMaster : public CComQIPtr<IJolietDiscMaster> 
{
public:
	HRESULT m_hr;

	CJolietDiscMaster(CDiscMaster& dm) : CComQIPtr<IJolietDiscMaster>(dm) { }

	long GetTotalDataBlocks() {
		long val=0;
		m_hr = (*this)->GetTotalDataBlocks(&val);
		TRACEHR(_T("CJolietDiscMaster::GetTotalDataBlocks"),m_hr);
		ASSERT(SUCCEEDED(m_hr));
		return val;
	}

	long GetUsedDataBlocks() {
		long val=0;
		m_hr = (*this)->GetTotalDataBlocks(&val);
		TRACEHR(_T("CJolietDiscMaster::GetUsedDataBlocks"),m_hr);
		ASSERT(SUCCEEDED(m_hr));
		return val;
	}

	long GetDataBlockSize() {
		long val=0;
		m_hr = (*this)->GetDataBlockSize(&val);
		TRACEHR(_T("CJolietDiscMaster::GetDataBlockSize"),m_hr);
		return val;
	}

	BOOL GetJolietProperties(IPropertyStorage** pstg)
	{
		m_hr = (*this)->GetJolietProperties(pstg);
		TRACEHR(_T("CJolietDiscMaster::GetJolietProperties"),m_hr);
		return SUCCEEDED(m_hr);
	}

	BOOL AddData(IStorage* stg, BOOL bOverwrite)
	{
		m_hr = (*this)->AddData(stg, bOverwrite);
		TRACEHR(_T("CJolietDiscMaster::AddData"),m_hr);
		return SUCCEEDED(m_hr);
	}
	
};