TnbImageMastering.h

[詳解]

#pragma once
#ifndef __ATLCOM_H__
 #error TnbImageMastering.h is necessary fot OLE Object.
#endif
 
 
 
#include "TnbPointerHandle.h"
#include "TnbStaticMap.h"
#include "TnbStrVector.h"
#include "TnbTickCount.h"
#include "TnbDynamicFunc.h"
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#ifndef __imapi2_h__
 
#ifndef IID_PPV_ARGS
    template<typename T> void** IID_PPV_ARGS_Helper(T** pp) 
    {   // make sure everyone derives from IUnknown
        static_cast<IUnknown*>(*pp);
        return reinterpret_cast<void**>(pp);
    }
    #define IID_PPV_ARGS(ppType) __uuidof(**(ppType)), IID_PPV_ARGS_Helper(ppType)
#endif
 
#ifndef __RPC__in
    #define __RPC__in
    #define __RPC__in_opt
    #define __RPC__in_ecount_full(X)
    #define __RPC__out
    #define __RPC__out_ecount_full(X)
    #define __RPC__out_ecount_part(X, Y)
    #define __RPC__deref_out_opt
    #define __RPC__deref_out_ecount_full_opt(X)
#endif
 
#include "sdk/imapi2.h"
#include "sdk/imapi2error.h"
#include "sdk/imapi2fs.h"
#include "sdk/imapi2fserror.h"
 
#endif //__imapi2_h__
 
#endif //_TnbDOXYGEN
 
 
 
//TNB Library
namespace TNB
{
 
 
 
}; //TNB
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#define EXTERN_IMAPI2_GUID(itf,id)   EXTERN_GUID(itf, id, 0x7F64, 0x5B0F,  0x8F, 0x00,  0x5D, 0x77, 0xAF, 0xBE, 0x26, 0x1E)
#define EXTERN_IMAPI2FS_GUID(itf,id) EXTERN_GUID(itf, id, 0x975B, 0x59BE,  0xA9, 0x60,  0x9A, 0x2A, 0x26, 0x28, 0x53, 0xA5)
 
EXTERN_IMAPI2_GUID(CLSID_MsftDiscMaster2        , 0x2735412E);
EXTERN_IMAPI2_GUID(CLSID_MsftDiscRecorder2      , 0x2735412D);
EXTERN_IMAPI2_GUID(CLSID_MsftDiscFormat2Erase   , 0x2735412B);
EXTERN_IMAPI2_GUID(CLSID_MsftDiscFormat2Data    , 0x2735412A);
EXTERN_IMAPI2FS_GUID(CLSID_MsftFileSystemImage  , 0x2C941FC5);
 
EXTERN_IMAPI2_GUID(LIBID_IMAPILib2              , 0x2735412F);
EXTERN_IMAPI2_GUID(IID_IDiscMaster2             , 0x2735412E);
EXTERN_IMAPI2_GUID(IID_IDiscRecorder2           , 0x2735412D);
EXTERN_IMAPI2_GUID(IID_IWriteEngine2            , 0x2735412C);
EXTERN_IMAPI2_GUID(IID_IDiscFormat2Erase        , 0x2735412B);
EXTERN_IMAPI2_GUID(IID_IDiscFormat2Data         , 0x2735412A);
EXTERN_IMAPI2_GUID(IID_IDiscFormat2TrackAtOnce  , 0x27354129);
EXTERN_IMAPI2_GUID(IID_IDiscFormat2RawCD        , 0x27354128);
EXTERN_IMAPI2_GUID(IID_IWriteSpeedDescriptor    , 0x27354123);
EXTERN_IMAPI2_GUID(IID_IMultisessionSequential  , 0x27354122);
EXTERN_IMAPI2_GUID(IID_DDiscFormat2EraseEvents  , 0x2735413A);
EXTERN_IMAPI2_GUID(IID_DDiscFormat2DataEvents   , 0x2735413C);
EXTERN_IMAPI2_GUID(IID_DDiscMaster2Events       , 0x27354131);
 
EXTERN_IMAPI2FS_GUID(LIBID_IMAPI2FS             , 0x2C941FD0);
EXTERN_IMAPI2FS_GUID(IID_IBootOptions           , 0x2C941FCE);
EXTERN_IMAPI2FS_GUID(IID_IFsiStream             , 0x2C941FCD);
EXTERN_IMAPI2FS_GUID(IID_IFileSystemImageResult , 0x2C941FCC);
EXTERN_IMAPI2FS_GUID(IID_IProgressItem          , 0x2C941FCB);
EXTERN_IMAPI2FS_GUID(IID_IEnumProgressItems     , 0x2C941FCA);
EXTERN_IMAPI2FS_GUID(IID_IProgressItems         , 0x2C941FC9);
EXTERN_IMAPI2FS_GUID(IID_IFsiDirectoryItem      , 0x2C941FC8);
EXTERN_IMAPI2FS_GUID(IID_IFsiFileItem           , 0x2C941FC7);
EXTERN_IMAPI2FS_GUID(IID_IEnumFsiItems          , 0x2C941FC6);
EXTERN_IMAPI2FS_GUID(IID_IFileSystemImage       , 0x2C941FC5);
EXTERN_IMAPI2FS_GUID(IID_DFileSystemImageEvents , 0x2C941FDF);
 
// LIB は 'Lib2' か '2FS'
#define _TnbImageMasterEventSuper(CLS, SID, LIB)                        \
    public ::ATL::CComObjectRootEx<::ATL::CComSingleThreadModel>,       \
    public ::ATL::CComCoClass<CLS>,                                     \
    public ::ATL::IDispatchImpl<    IDispatch, &SID, &LIBID_IMAPI##LIB, IMAPI##LIB##_MajorVersion, IMAPI##LIB##_MinorVersion>,  \
    public ::ATL::IDispEventImpl<1, CLS,       &SID, &LIBID_IMAPI##LIB, IMAPI##LIB##_MajorVersion, IMAPI##LIB##_MinorVersion>
 
#define _TnbImageMasterEventMember(CLS)         \
    DECLARE_NOT_AGGREGATABLE(CLS)               \
    BEGIN_COM_MAP(CLS)                          \
        COM_INTERFACE_ENTRY(IDispatch)          \
    END_COM_MAP()
 
struct  IImageMasteringWriterListener
{
    virtual void OnWriterEvent(IDispatch* pObject, IDispatch* pProgressDisp) = 0;
};
 
class CImageMasteringWriterEvent : _TnbImageMasterEventSuper(CImageMasteringWriterEvent, IID_DDiscFormat2DataEvents, Lib2)
{
    _TnbImageMasterEventMember(CImageMasteringWriterEvent)
    BEGIN_SINK_MAP(CImageMasteringWriterEvent)
        SINK_ENTRY_EX(1, IID_DDiscFormat2DataEvents, DISPID_DDISCFORMAT2DATAEVENTS_UPDATE, &Update)
    END_SINK_MAP()
public:
    STDMETHOD_(VOID, Update)(IDispatch* pObject, IDispatch* pProgressDisp)
    {
        m_pListener->OnWriterEvent(pObject, pProgressDisp);
    }
    IImageMasteringWriterListener* m_pListener;
};
 
struct  IImageMasteringEraseListener
{
    virtual void OnEraseEvent(IDispatch* pObject, LONG elapsedSeconds, LONG expectedSeconds) = 0;
};
 
class  CImageMasteringEraseEvent : _TnbImageMasterEventSuper(CImageMasteringEraseEvent, IID_DDiscFormat2EraseEvents, Lib2)
{
    _TnbImageMasterEventMember(CImageMasteringEraseEvent)
    BEGIN_SINK_MAP(CImageMasteringEraseEvent)
        SINK_ENTRY_EX(1, IID_DDiscFormat2EraseEvents, DISPID_IDISCFORMAT2ERASEEVENTS_UPDATE, &Update)
    END_SINK_MAP()
public:
    STDMETHOD_(VOID, Update)(IDispatch* pObject, LONG elapsedSeconds, LONG expectedSeconds)
    {
        m_pListener->OnEraseEvent(pObject, elapsedSeconds, expectedSeconds);
    }
    IImageMasteringEraseListener* m_pListener;
};
 
struct  IImageMasteringFileListener
{
    virtual void OnFileEvent(IDispatch* pObject, BSTR currentFile, LONG copiedSectors, LONG totalSectors) = 0;
};
 
class  CImageMasteringFileEvent : _TnbImageMasterEventSuper(CImageMasteringFileEvent, IID_DFileSystemImageEvents, 2FS)
{
    _TnbImageMasterEventMember(CImageMasteringFileEvent)
    BEGIN_SINK_MAP(CImageMasteringFileEvent)
        SINK_ENTRY_EX(1, IID_DFileSystemImageEvents, DISPID_DFILESYSTEMIMAGEEVENTS_UPDATE, &Update)
    END_SINK_MAP()
public:
    STDMETHOD_(VOID, Update)(IDispatch* pObject, BSTR currentFile, LONG copiedSectors, LONG totalSectors)
    {
        m_pListener->OnFileEvent(pObject, currentFile, copiedSectors, totalSectors);
    }
    IImageMasteringFileListener* m_pListener;
};
 
struct  IImageMasteringListener
{
    virtual void OnAddedDevice(IDispatch* pObject, BSTR value);
    virtual void OnRemovedDevice(IDispatch* pObject, BSTR value);
};
 
class CImageMasteringEvent : _TnbImageMasterEventSuper(CImageMasteringEvent, IID_DDiscMaster2Events, Lib2)
{
public:
    _TnbImageMasterEventMember(CImageMasteringEvent)
    BEGIN_SINK_MAP(CImageMasteringEvent)
        SINK_ENTRY_EX(1, IID_DDiscMaster2Events, DISPID_DDISCMASTER2EVENTS_DEVICEADDED,   &NotifyDeviceAdded  )
        SINK_ENTRY_EX(1, IID_DDiscMaster2Events, DISPID_DDISCMASTER2EVENTS_DEVICEREMOVED, &NotifyDeviceRemoved)
    END_SINK_MAP()
public:
    STDMETHOD_(VOID, NotifyDeviceAdded)(IDispatch* pObject, BSTR value)
    {
        m_pListener->OnAddedDevice(pObject, value);
    }
    STDMETHOD_(VOID, NotifyDeviceRemoved)(IDispatch* pObject, BSTR value)
    {
        m_pListener->OnRemovedDevice(pObject, value);
    }
    IImageMasteringListener* m_pListener;
};
 
template<typename T> struct TImReleasePointerT
{
    void operator()(T P) { P->Release(); }
};
 
#endif // _TnbDOXYGEN
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CImageMasteringResult
{
public:
    
    CImageMasteringResult(void) : m_lastResult(S_OK)
    {
        #ifdef __MSVCPP6__
            ASSERT( _pModule != NULL );
        #else 
            if ( _pAtlModule == NULL )
            {
                static CAtlMfcModule a;
                VERIFY( ::OleInitialize(NULL) == S_OK );
            }
        #endif
    }
 
    HRESULT GetLastResult(void) const
    {
        return m_lastResult;
    }
 
    CStr GetLastResultString(void) const
    {
        return ToString(m_lastResult);
    }
 
    static CStr ToString(HRESULT hr)
    {
        CStr s = _T("Unknown");
        DWORD flag = FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER;
        LPVOID lpMsgBuf;
        LPWSTR lpBuff = reinterpret_cast<LPWSTR>(&lpMsgBuf);
        DWORD ret = ::FormatMessageW(flag | FORMAT_MESSAGE_FROM_HMODULE
                        , ::GetModuleHandle(_T("imapi2.dll"))
                        , hr, LANG_USER_DEFAULT, lpBuff, 0, NULL);
        if ( ret == 0 )
        {
            _GetLastError("FormatMessage");
            ret = ::FormatMessageW(flag | FORMAT_MESSAGE_FROM_HMODULE
                        , ::GetModuleHandle(_T("imapi2fs.dll"))
                        , hr, LANG_USER_DEFAULT, lpBuff, 0, NULL);
        }
        if (ret == 0)
        {
            _GetLastError("FormatMessage");
            ret = ::FormatMessageW(flag | FORMAT_MESSAGE_FROM_SYSTEM
                        , NULL
                        , hr, LANG_USER_DEFAULT, lpBuff, 0, NULL);
        }
        if ( ret == 0 )
        {
            _GetLastError("FormatMessage");
        }
        else
        {
            s = static_cast<LPCWSTR>(lpMsgBuf);
//          s.TrimRight('\n').TrimRight('\r');
            s.TrimRight(_T("\n\r"));
            ::LocalFree(lpMsgBuf);
        }
        return s;
    }
 
    static HRESULT CreateStreamOnFile(LPCTSTR lpszFile, DWORD grfMode, IStream **ppstm)
    {
        try
        {
            #ifdef _UNICODE
                typedef HRESULT (WINAPI* P_CSOFW)(LPCWSTR, DWORD, IStream**);
                CDynamicFuncT<P_CSOFW> func("shlwapi.dll", "SHCreateStreamOnFileW");
            #else
                typedef HRESULT (WINAPI* P_CSOFA)(LPCSTR, DWORD, IStream**);
                CDynamicFuncT<P_CSOFA> func("shlwapi.dll", "SHCreateStreamOnFileA");
            #endif
            return func()(lpszFile, grfMode, ppstm);
        }
        catch ( CNullPointerException& e )
        {
            e.OnCatch();
        }
        return E_FAIL;
    }
 
protected:
 
    bool CheckRes(HRESULT hr) const
    {
        m_lastResult = hr;
        if ( SUCCEEDED(hr) )
        {
            return true;
        }
        TRACE2(" Result =(0x%08X,[%s]\n", hr, ToString(hr));
        return false;
    }
 
private:
    mutable HRESULT m_lastResult;
};
 
 
 
class CImageMastering : public CImageMasteringResult, CCopyImpossible
{
public:
 
    typedef CPointerHandleBaseT<IDiscMaster2*, TImReleasePointerT<IDiscMaster2*> > CDiscMasterHandle;
 
    typedef CPointerHandleBaseT<IDiscRecorder2*, TImReleasePointerT<IDiscRecorder2*> > CDiscRecorderHandle;
 
    typedef CPointerHandleBaseT<IFileSystemImage*, TImReleasePointerT<IFileSystemImage*> > CFileSystemImageHandle;
 
    typedef CPointerHandleBaseT<IDiscFormat2Data*, TImReleasePointerT<IDiscFormat2Data*> > CDiscFormatDataHandle;
 
    typedef CPointerHandleBaseT<IDiscFormat2Erase*, TImReleasePointerT<IDiscFormat2Erase*> > CDiscFormatEraseHandle;
 
 
    //-------------------------------------------------------
 
 
    class CDiscImage : public CImageMasteringResult, CCopyImpossible, IImageMasteringFileListener
    {
    public:
 
        struct IListener
        {
            virtual ~IListener(void) {}
 
            virtual void OnDiscImageAdded(LPCTSTR file, LONG copiedSectors, LONG totalSectors) = 0;
        };
 
        CDiscImage(void) : m_useJoliet(true), m_pListener(NULL), m_pEventSink(NULL), m_pRoot(NULL)
        {
            Reset();
        }
 
        ~CDiscImage(void)
        {
            m_ReleaseSink();
            if ( m_pRoot != NULL )
            {
                m_pRoot->Release();
                m_pRoot = NULL;
            }
        }
 
        bool IsValid(void) const
        {
            return m_pRoot != NULL;
        }
 
        IFileSystemImage* operator->(void) const
        {
            return m_hpImage;
        }
 
        bool Reset(void)
        {
            m_pListener = NULL;
            m_ReleaseSink();
            if ( m_pRoot != NULL )
            {
                m_pRoot->Release();
                m_pRoot = NULL;
            }
            IFileSystemImage* P = NULL;
            if ( CheckRes(::CoCreateInstance(CLSID_MsftFileSystemImage, NULL, CLSCTX_ALL, IID_PPV_ARGS(&P))) )
            {
                m_hpImage = P;
                if ( CheckRes(m_hpImage->put_FreeMediaBlocks(0/*infinite*/)) )
                {
                    CheckRes(m_hpImage->get_Root(&m_pRoot));
                }
            }
            return m_pRoot != NULL;
        }
 
        void SetJolietSystem(bool isEnable)
        {
            m_useJoliet = isEnable;
        }
 
        void SetListener(IListener* P)
        {
            m_pListener = P;
            m_ReleaseSink();
            if ( P != NULL )
            {
                if ( CheckRes(CComObject<CImageMasteringFileEvent>::CreateInstance(&m_pEventSink)) )
                {
                    m_pEventSink->AddRef();
                    m_pEventSink->m_pListener = this;
                    CheckRes(m_pEventSink->DispEventAdvise(m_hpImage));
                }
            }
        }
 
        size_t GetSectorSize(bool isXA = false) const
        {
            return isXA ? 2336 : 2048;
        }
 
        size_t GetSectorsCount(void) const
        {
            LONG r;
            return CheckRes(m_hpImage->get_UsedBlocks(&r)) ? r : 0;
        }
 
        size_t GetFileCount(void) const
        {
            LONG r;
            return CheckRes(m_hpImage->get_FileCount(&r)) ? r : 0;
        }
 
        size_t GetDirectoryCount(void) const
        {
            LONG r;
            return CheckRes(m_hpImage->get_DirectoryCount(&r)) ? r : 0;
        }
 
        CStr GetVolumeName(void) const
        {
            CStr r;
            CComBSTR s;
            if ( CheckRes(m_hpImage->get_VolumeName(&s)) )
            {
                r = s;
            }
            return r;
        }
 
        bool SetVolumeName(LPCTSTR lpszVolume)
        {
            CComBSTR s = lpszVolume;
            return CheckRes(m_hpImage->put_VolumeName(s));
        }
 
        bool AddSourceDirectory(LPCTSTR lpszPath, LPCTSTR lpszImagePath = NULL)
        {
            IFsiDirectoryItem* pDir = NULL;
            CComBSTR name = lpszPath;
            if ( lpszImagePath == NULL )
            {
                return CheckRes(m_pRoot->AddTree(name, false));
            }
            HRESULT hr = m_AddDirectory(m_pRoot, lpszImagePath);
            if ( SUCCEEDED(hr) )
            {
                CComBSTR path = lpszImagePath;
                hr = m_pRoot->get_Item(path, reinterpret_cast<IFsiItem**>(&pDir));
                if ( SUCCEEDED(hr) && lpszPath != NULL )
                {
                    hr = pDir->AddTree(name, false);
                    pDir->Release();
                    pDir = NULL;
                }
            }
            return CheckRes(hr);
        }
 
        bool AddSourceFile(LPCTSTR lpszName, LPCTSTR lpszImagePath = NULL)
        {
            IFsiDirectoryItem* pDir = NULL;
            if ( lpszImagePath == NULL )
            {
                return CheckRes(m_AddFile(m_pRoot, lpszName));
            }
            HRESULT hr = m_AddDirectory(m_pRoot, lpszImagePath);
            if ( SUCCEEDED(hr) )
            {
                CComBSTR path = lpszImagePath;
                hr = m_pRoot->get_Item(path, reinterpret_cast<IFsiItem**>(&pDir));
                if ( SUCCEEDED(hr) && lpszName != NULL )
                {
                    hr = m_AddFile(pDir, lpszName);
                    pDir->Release();
                    pDir = NULL;
                }
            }
            return CheckRes(hr);
        }
 
        bool RemoveDirectory(LPCTSTR lpszImagePath)
        {
            CComBSTR s = lpszImagePath;
            return CheckRes(m_pRoot->RemoveTree(s));
        }
 
        bool RemoveFile(LPCTSTR lpszImageName)
        {
            CComBSTR s = lpszImageName;
            return CheckRes(m_pRoot->Remove(s));
        }
 
        bool SetBootImage(LPCTSTR lpszBootFileName)
        {
            IBootOptions* pBootOptions = NULL;
            if ( ! CheckRes(::CoCreateInstance(CLSID_BootOptions, NULL, CLSCTX_ALL, IID_PPV_ARGS(&pBootOptions))) )
            {
                return false;
            }
            IStream* pBootStream = NULL;
            HRESULT hr = CreateStreamOnFile(lpszBootFileName
                        , STGM_READ | STGM_SHARE_DENY_WRITE, &pBootStream);
            if ( SUCCEEDED(hr) )
            {
                hr = pBootOptions->AssignBootImage(pBootStream);
            }
            if ( SUCCEEDED(hr) )
            {
                hr = m_hpImage->put_BootImageOptions(pBootOptions);
            }
            if ( pBootStream != NULL )
            {
                pBootStream->Release();
                pBootStream = NULL;
            }
            pBootOptions->Release();
            pBootOptions = NULL;
            return CheckRes(hr);
        }
 
        bool SetWorkingDirestory(LPCTSTR lpszPath)
        {
            CComBSTR s = lpszPath;
            return CheckRes(m_hpImage->put_WorkingDirectory(s));
        }
 
        struct TFileItem
        {
            bool    isDirectory;    
            CStr    name;           
        };
 
        bool EnumerationFiles(CVectorT<TFileItem>& _items) const
        {
            return m_EnumFiles(_items, m_pRoot);
        }
 
        bool CreateImageFile(LPCTSTR lpszFileName, IMAPI_MEDIA_PHYSICAL_TYPE type = IMAPI_MEDIA_TYPE_CDR)
        {
            IStream* pSrcStream = CreateImageSteam(type);
            if ( pSrcStream != NULL )
            {
                IStream* pDstStream = NULL;
                HRESULT hr = CreateStreamOnFile(lpszFileName
                            , STGM_WRITE | STGM_CREATE, &pDstStream);
                if ( SUCCEEDED(hr) )
                {
                    STATSTG stat = { 0 };
                    hr = pSrcStream->Stat(&stat, STATFLAG_NONAME);
                    if ( SUCCEEDED(hr) )
                    {
                        ULARGE_INTEGER cbRead = {0};
                        ULARGE_INTEGER cbWritten = {0};
                        hr = pSrcStream->CopyTo(pDstStream, stat.cbSize, &cbRead, &cbWritten);
                    }
                    pDstStream->Release();
                    pDstStream = NULL;
                }
                pSrcStream->Release();
                pSrcStream = NULL;
                return CheckRes(hr);
            }
            return false;
        }
 
        IStream* CreateImageSteam(IMAPI_MEDIA_PHYSICAL_TYPE type = IMAPI_MEDIA_TYPE_CDR) const
        {
            HRESULT hr = m_hpImage->put_FileSystemsToCreate(m_ToFileSystem(type));
            if ( SUCCEEDED(hr) )
            {
                IFileSystemImageResult* pResultStream = NULL;
                hr = m_hpImage->CreateResultImage(&pResultStream);
                if ( SUCCEEDED(hr) )
                {
                    IStream* pStream = NULL;
                    hr = pResultStream->get_ImageStream(&pStream);
                    pResultStream->Release();
                    pResultStream = NULL;
                    if ( SUCCEEDED(hr) )
                    {
                        return pStream;
                    }
                }
            }
            VERIFY( ! CheckRes(hr) );
            return NULL;
        }
 
    private:
        // [取得] ファイルシステム種類取得.
        FsiFileSystems m_ToFileSystem(IMAPI_MEDIA_PHYSICAL_TYPE type = IMAPI_MEDIA_TYPE_CDR) const
        {
            FsiFileSystems f = FsiFileSystemUDF;
            switch ( type )
            {
            case IMAPI_MEDIA_TYPE_CDROM:
            case IMAPI_MEDIA_TYPE_CDR:
            case IMAPI_MEDIA_TYPE_CDRW:
                if ( m_useJoliet )
                {
                    f = static_cast<FsiFileSystems>(FsiFileSystemJoliet | FsiFileSystemISO9660);
                }
                else
                {
                    f = FsiFileSystemISO9660;
                }
                break;
            default:
                break;
            }
            return f;
        }
        // ディレクトリ追加
        HRESULT m_AddDirectory(IFsiDirectoryItem* _pDir, LPCTSTR lpszPath)
        {
            CStr path = lpszPath;
//          path.TrimLeft('\\').TrimLeft('/').TrimRight('\\').TrimRight('/');
            path.Trim(_T("\\/"));
            if ( path.IsEmpty() )
            {
                return S_OK;
            }
//          INT_PTR f = path.ReverseFind('\\');
//          if ( f < 0 )
//          {
//              f = path.ReverseFind('/');
//          }
            INT_PTR f = path.ReverseFindOneOf(_T("\\/"));
            if ( f >= 0 )
            {
                HRESULT hr = m_AddDirectory(_pDir, path.Left(f));
                if ( ! SUCCEEDED(hr) )
                {
                    return hr;
                }
            }
            CComBSTR p = path;
            return _pDir->AddDirectory(p);
        }
        // ファイル追加
        HRESULT m_AddFile(IFsiDirectoryItem* _pDir, LPCTSTR lpszFileName)
        {
            IStream* pStream = NULL;
            HRESULT hr = CreateStreamOnFile(lpszFileName
                        , STGM_READ | STGM_SHARE_DENY_WRITE, &pStream);
            if ( SUCCEEDED(hr) )
            {
                CStr s = lpszFileName;
//              INT_PTR f = s.ReverseFind(_T("\\"));
//              if ( f < 0 )
//              {
//                  f = s.ReverseFind(_T("/"));
//              }
                INT_PTR f = s.ReverseFindOneOf(_T("\\/"));
                if ( f >= 0 )
                {
                    s = s.Mid(f + 1);
                }
                CComBSTR name = s;
                //hr = _pDir->AddFile(name, pStream); //これだと日付が今になってしまう
                STATSTG stat = { 0 };
                hr = pStream->Stat(&stat, STATFLAG_NONAME);
                if ( SUCCEEDED(hr) )
                {
                    IFsiFileItem* I = NULL;
                    hr = m_hpImage->CreateFileItem(name, &I);
                    if ( SUCCEEDED(hr) )
                    {
                        I->put_Data(pStream);
                        I->put_CreationTime(COleDateTime(stat.ctime));
                        I->put_LastAccessedTime(COleDateTime(stat.atime));
                        I->put_LastModifiedTime(COleDateTime(stat.mtime));
                        hr = _pDir->Add(I);
                        I->Release();
                        I =NULL;
                    }
                }
                pStream->Release();
                pStream = NULL;
            }
            return hr;
        }
        bool m_EnumFiles(CVectorT<TFileItem>& _items, IFsiDirectoryItem* pDirs) const
        {
            IEnumFsiItems* pItems = NULL;
            HRESULT hr = pDirs->get_EnumFsiItems(&pItems);
            ULONG celt = 0;
            while ( true )
            {
                IFsiItem* pFI = NULL;
                hr = pItems->Next(1, &pFI, &celt);
                if ( hr != S_OK )
                {
                    break;
                }
                if ( pFI != NULL )
                {
                    TFileItem fi;
                    IFsiDirectoryItem* P = NULL;
                    fi.isDirectory = SUCCEEDED(pFI->QueryInterface(&P));
                    CComBSTR s;
                    pFI->get_FullPath(&s);
                    fi.name = s;
                    _items.Add(fi);
                    if ( P != NULL && ! m_EnumFiles(_items, P) )
                    {
                        break;
                    }
                    pFI->Release();
                    pFI = NULL;
                }
                pItems->Skip(celt);
            }
            pItems->Release();
            pItems = NULL;
            return CheckRes(hr);
        }
        void m_ReleaseSink(void)
        {
            if ( m_pEventSink != NULL )
            {
                m_pEventSink->DispEventUnadvise(m_pRoot);
                m_pEventSink->Release();
                m_pEventSink = NULL;
            }
        }
        virtual void OnFileEvent(IDispatch* object, BSTR currentFile, LONG copiedSectors, LONG totalSectors)
        {
            if ( m_pListener != NULL )
            {
                m_pListener->OnDiscImageAdded(CStr(currentFile), copiedSectors, totalSectors);
            }
        }
        bool                                    m_useJoliet;    
        IFsiDirectoryItem*                      m_pRoot;        
        CFileSystemImageHandle                  m_hpImage;      
        IListener*                              m_pListener;    
        CComObject<CImageMasteringFileEvent>*   m_pEventSink;   
    };
 
 
    //-------------------------------------------------------------
 
 
    class CDrive : public CImageMasteringResult
    {
    public:
 
        struct IListener
        {
            class CProgressData
            {
            public:
                virtual LONG GetRemainingTime(void) const = 0;
                virtual LONG GetElapsedTime(void) const = 0;
                virtual LONG GetExpectedTime(void) const = 0;
                virtual LONG GetStartLba(void) const = 0;
                virtual LONG GetTotalSectorCount(void) const = 0;
                virtual LONG GetWrittenLba(void) const = 0;
                virtual LONG GetWrittenSector(void) const = 0;
            };
 
            virtual ~IListener(void) {}
 
            virtual void OnDriveErrorResult(HRESULT hr) = 0;
 
            virtual bool OnDriveWriteEvent(const CProgressData& pd, IMAPI_FORMAT2_DATA_WRITE_ACTION action) = 0;
 
            virtual void OnDriveEraseEvent(const CProgressData& pd) = 0;
        };
 
 
        //-----------------------------------
 
 
        CDrive(CDiscRecorderHandle dr, LPCTSTR name)
        {
            m_Recorder() = dr;
            if ( ! m_Recorder().IsNull() )
            {
                CComBSTR s = name;
                if ( ! CheckRes(m_Recorder()->InitializeDiscRecorder(s)) )
                {
                    m_Recorder().Null();
                }
                m_Writer() = m_CreateDiscFormatData();
                if ( m_Writer().IsNull() )
                {
                    m_Recorder().Null();
                }
            }
        }
 
        bool IsValid(void) const
        {
            return ! m_Recorder().IsNull();
        }
 
        IDiscRecorder2* operator->(void)
        {
            return m_Recorder();
        }
 
        void SetListener(IListener* pListener)
        {
            m_member.pListener = pListener;
        }
 
        bool Erase(bool isFull = false)
        {
            CDiscFormatEraseHandle hpEraser = m_CreateDiscFormatErase();
            HRESULT hr = S_OK;
            if ( isFull )
            {
                hr = hpEraser->put_FullErase(VARIANT_TRUE);
            }
            if ( CheckRes(hr) )
            {
                CComObject<CImageMasteringEraseEvent>* pEventSink = NULL;
                if ( CheckRes(CComObject<CImageMasteringEraseEvent>::CreateInstance(&pEventSink)) )
                {
                    pEventSink->AddRef();
                    pEventSink->m_pListener = &m_member;
                    pEventSink->DispEventAdvise(hpEraser);
                    hr = hpEraser->EraseMedia();
                    bool r = CheckRes(hr);
                    pEventSink->DispEventUnadvise(hpEraser);
                    pEventSink->Release();
                    pEventSink = NULL;
                    return r;
                }
            }
            return false;
        }
 
        bool Burn(const CDiscImage& discImage, bool isClose = true)
        {
            IFileSystemImage* pImage = discImage.operator->();
            if ( pImage == NULL )
            {
                return false;
            }
            LONG changePoint = -1;
            bool r = CheckRes(pImage->get_ChangePoint(&changePoint));
            IStream* pSrcStream = NULL;
            if ( r )
            {
                pSrcStream = discImage.CreateImageSteam(GetTypeOnDisc());
                if ( pSrcStream == NULL )
                {
                    r = CheckRes(discImage.GetLastResult());
                    ASSERT( ! r );
                }
            }
            r = m_SetCloseDiscMode(isClose);
            if ( r )
            {
                r = m_CheckDvdplusrdl();
            }
            if ( r && ! IsBlankDisc() && IsAppendableDisc() )
            {
                r = m_MultiDisp(pImage);
            }
            if ( r )
            {
                r = m_Burn(pSrcStream);
            }
            if ( pSrcStream != NULL )
            {
                pSrcStream->Release();
                pSrcStream = NULL;
            }
            if ( changePoint >= 0 )
            {
                pImage->RollbackToChangePoint(changePoint);
            }
            return r;
        }
 
        bool Burn(LPCTSTR lpszFileName, bool isClose = true)
        {
            if ( m_Writer().IsNull() )
            {
                return false;
            }
            if ( ! m_SetCloseDiscMode(isClose) )
            {
                return false;
            }
            IStream* pStream = NULL;
            HRESULT hr = CreateStreamOnFile(lpszFileName
                        , STGM_READ | STGM_SHARE_DENY_WRITE, &pStream);
            bool r = CheckRes(hr);
            if ( r )
            {
                r = m_Burn(pStream);
            }
            if ( pStream != NULL )
            {
                pStream->Release();
                pStream = NULL;
            }
            return r;
        }
 
        bool OpenTray(void)
        {
            return m_Tray(true);
        }
 
        bool CloseTray(void)
        {
            return m_Tray(false);
        }
 
        struct TInformation
        {
            CStr    vendorId;       
            CStr    productId;      
            CStr    productRevision;
        };
 
        TInformation GetInformation(void) const
        {
            TInformation info;
            if ( ! m_Recorder().IsNull() )
            {
                info.vendorId       = m_GetBstrKindString(BstrKind_VendorId);
                info.productId      = m_GetBstrKindString(BstrKind_ProductId);
                info.productRevision= m_GetBstrKindString(BstrKind_ProductRevision);
            }
            return info;
        }
 
        bool EnumerationMountPath(CStrVector& _mountPaths) const
        {
            _mountPaths.RemoveAll();
            SAFEARRAY* pSA = NULL;
            if ( ! m_Recorder().IsNull() && CheckRes(m_Recorder()->get_VolumePathNames(&pSA)) )
            {
                VARIANT* P = static_cast<VARIANT*>(pSA->pvData);
                loop ( i, pSA->rgsabound[0].cElements )
                {
                    ASSERT( P[i].vt == VT_BSTR );
                    _mountPaths.Add(CStr(P[i].bstrVal));
                }
                ::SafeArrayDestroyData(pSA);
                pSA = NULL;
                return true;
            }
            return false;
        }
 
        size_t GetSectorSize(void) const
        {
            return 2048;
        }
 
        bool EnumerationSupportWriteSpeeds(CWordVector& _speeds) const
        {
            _speeds.RemoveAll();
            SAFEARRAY* pSA = NULL;
            if ( ! m_Writer().IsNull() && CheckRes(m_Writer()->get_SupportedWriteSpeeds(&pSA)) )
            {
                VARIANT* P = static_cast<VARIANT*>(pSA->pvData);
                loop ( i, pSA->rgsabound[0].cElements )
                {
                    _speeds.Add(static_cast<WORD>(P[i].ulVal));
                }
                ::SafeArrayDestroyData(pSA);
                pSA = NULL;
                return true;
            }
            return false;
        }
 
        bool SetWriteSpeed(int speed = -1, bool isPureCAV = false)
        {
            if ( ! m_Writer().IsNull() )
            {
                VARIANT_BOOL r = isPureCAV ? VARIANT_TRUE : VARIANT_FALSE;
                return CheckRes(m_Writer()->SetWriteSpeed(speed, r));
            }
            return false;
        }
 
        size_t GetTotalSectorsOnDisc(void) const
        {
            if ( ! m_Writer().IsNull() )
            {
                LONG l;
                if ( CheckRes(m_Writer()->get_TotalSectorsOnMedia(&l)) )
                {
                    return l;
                }
            }
            return 0;
        }
 
        size_t GetFreeSectorsOnDisc(void) const
        {
            if ( ! m_Writer().IsNull() )
            {
                LONG l;
                if ( CheckRes(m_Writer()->get_FreeSectorsOnMedia(&l)) )
                {
                    return l;
                }
            }
            return 0;
        }
 
        bool ExistDisc(DWORD time = 0) const
        {
            if ( ! m_Writer().IsNull() )
            {
                VARIANT_BOOL isBlank = FALSE;
                CTickCount ti;
                while ( true )
                {
                    HRESULT hr = m_Writer()->get_MediaHeuristicallyBlank(&isBlank);
                    if ( hr == E_IMAPI_RECORDER_MEDIA_NO_MEDIA || hr == E_IMAPI_RECORDER_MEDIA_BECOMING_READY )
                    {
                        if ( ! ti.IsPassed(time) )
                        {
                            ::Sleep(200);
                            continue;
                        }
                        CheckRes(S_OK);
                        return false;
                    }
                    return CheckRes(hr);
                }
            }
            return false;
        }
 
        int GetStatusOnDisc(void) const
        {
            IMAPI_FORMAT2_DATA_MEDIA_STATE s = IMAPI_FORMAT2_DATA_MEDIA_STATE_UNKNOWN;
            if ( ! m_Writer().IsNull() )
            {
                CheckRes(m_Writer()->get_CurrentMediaStatus(&s));
            }
            return s;
        }
 
        CStr GetVolumeOnDisc(void) const
        {
            CStrVector mountPaths;
            if ( EnumerationMountPath(mountPaths) )
            {
                loop ( i, mountPaths.GetSize() )
                {
                    CStr path;
                    DWORD serialNumber;
                    DWORD maxLen;
                    DWORD fileSystemFlags;
                    bool r = !!::GetVolumeInformation(mountPaths[i], path.GetBuffer(1000), 1000
                                    , &serialNumber, &maxLen, &fileSystemFlags, NULL, 0);
                    if ( r )
                    {
                        path.ReleaseBuffer();
                        return path;
                    }
                }
            }
            return _T("");
        }
 
        bool IsBlankDisc(void) const
        {
            if ( ! m_Writer().IsNull() )
            {
                VARIANT_BOOL isBlank = FALSE;
                HRESULT hr = m_Writer()->get_MediaHeuristicallyBlank(&isBlank);
                if ( CheckRes(hr) )
                {
                    return !! isBlank;
                }
            }
            return false;
        }
 
        bool IsAppendableDisc(void) const
        {
            return (GetStatusOnDisc() & IMAPI_FORMAT2_DATA_MEDIA_STATE_APPENDABLE) != 0;
        }
 
        typedef CVectorT<IMAPI_MEDIA_PHYSICAL_TYPE> CTypeVector;
 
        bool EnumerationSupportedDiscTypes(CTypeVector& _types) const
        {
            _types.RemoveAll();
            SAFEARRAY* pSA = NULL;
            if ( ! m_Writer().IsNull() && CheckRes(m_Writer()->get_SupportedMediaTypes(&pSA)) )
            {
                VARIANT* P = static_cast<VARIANT*>(pSA->pvData);
                loop ( i, pSA->rgsabound[0].cElements )
                {
                    ASSERT( P[i].vt == VT_I4 );
                    IMAPI_MEDIA_PHYSICAL_TYPE t = static_cast<IMAPI_MEDIA_PHYSICAL_TYPE>(P[i].lVal);
                    _types.Add(t);
                }
                ::SafeArrayDestroyData(pSA);
                pSA = NULL;
                return true;
            }
            return false;
        }
 
        IMAPI_MEDIA_PHYSICAL_TYPE GetTypeOnDisc(void) const
        {
            IMAPI_MEDIA_PHYSICAL_TYPE type = IMAPI_MEDIA_TYPE_UNKNOWN;
            if ( ! m_Writer().IsNull() )
            {   
                CheckRes(m_Writer()->get_CurrentPhysicalMediaType(&type));
            }
            return type;
        }
 
        CStr GetTypeStringOnDisc(void) const
        {
            return CImageMastering::ToString(GetTypeOnDisc());
        }
 
        bool ReadMultiSession(CDiscImage& _diskImage) const
        {
            IFileSystemImage* pImage = _diskImage.operator ->();
            bool r = m_MultiDisp(pImage);
            CStr s = GetVolumeOnDisc();
            if ( ! s.IsEmpty() )
            {
                _diskImage.SetVolumeName(s);
            }
            return r;
        }
 
    private:
        bool m_Burn(IStream* pStream)
        {
            ASSERT( pStream != NULL );
            CComObject<CImageMasteringWriterEvent>* pEventSink = NULL;
            HRESULT hr = CComObject<CImageMasteringWriterEvent>::CreateInstance(&pEventSink);
            if ( SUCCEEDED(hr) )
            {
                ASSERT( pEventSink != NULL );
                pEventSink->AddRef();
                pEventSink->m_pListener = &m_member;
                pEventSink->DispEventAdvise(m_Writer());
                hr = m_Writer()->Write(pStream);
                pEventSink->DispEventUnadvise(m_Writer());
                pEventSink->Release();
                pEventSink = NULL;
            }
            return CheckRes(hr);
        }
        // Close the disc if specified
        bool m_SetCloseDiscMode(bool isClose = true)
        {
            HRESULT hr = m_Writer()->put_ForceMediaToBeClosed(isClose ? VARIANT_TRUE : VARIANT_FALSE);
            return CheckRes(hr);
        }
        // verify the StartAddressOfPreviousSession property 
        // ALSO -- for DVD+R DL, if from sector zero, set to finalize media
        bool m_CheckDvdplusrdl(void)
        {
            return true;
#if 0
            LONG value = 0;
            HRESULT hr = m_Writer()->get_StartAddressOfPreviousSession(&value);
            if ( SUCCEEDED(hr) && value == -1 )
            {
                hr = m_Writer()->put_ForceMediaToBeClosed(VARIANT_TRUE);
            }
            return CheckRes(hr);
#endif
        }
        // ImportFileSystem - Import file data from disc
        bool m_MultiDisp(IFileSystemImage* pImage) const
        {
            SAFEARRAY* pSA = NULL;
            if ( SUCCEEDED(pImage->get_MultisessionInterfaces(&pSA)) )
            {
                ULONG l = pSA->rgsabound[0].cElements;
                ::SafeArrayDestroyData(pSA);
                if ( l > 0 )
                {
                    // セッション登録済み
                    return true;
                }
            }
            SAFEARRAY* pMultiSession = NULL;
            // Get mutlisession interface to set in image
            HRESULT hr = m_Writer()->get_MultisessionInterfaces(&pMultiSession);
            // Set the multisession interface in the image
            if ( SUCCEEDED(hr) )
            {
                hr = pImage->put_MultisessionInterfaces(pMultiSession);
            }
            if ( SUCCEEDED(hr) )
            {
                FsiFileSystems fileSystems;
                hr = pImage->ImportFileSystem(&fileSystems);
                if ( hr == IMAPI_E_EMPTY_DISC )
                {
                    // Empty Disc は OK 
                    hr = S_OK;
                }
            }
            if ( pMultiSession != NULL )
            {
                ::SafeArrayDestroy(pMultiSession);
                pMultiSession = NULL;
            }
            return CheckRes(hr);
        }
        bool m_Tray(bool isOpen)
        {
            if ( ! m_Recorder().IsNull() )
            {
                if ( CheckRes(m_Recorder()->DisableMcn()) )
                {
                    bool r = CheckRes(isOpen ? m_Recorder()->EjectMedia() : m_Recorder()->CloseTray());
                    m_Recorder()->EnableMcn();
                    return r;
                }
            }
            return false;
        }
        enum EBstrKind
        {
            BstrKind_VendorId,              
            BstrKind_ProductId,             
            BstrKind_ProductRevision,       
            BstrKind_ExclusiveAccessOwner,  
        };
        CStr m_GetBstrKindString(EBstrKind k) const
        {
            CStr s;
            if ( ! m_Recorder().IsNull() )
            {
                CComBSTR str;
                HRESULT hr = E_FAIL;
                switch ( k )
                {
                case BstrKind_VendorId:
                    hr = m_Recorder()->get_VendorId(&str);
                    break;
                case BstrKind_ProductId:
                    hr = m_Recorder()->get_ProductId(&str);
                    break;
                case BstrKind_ProductRevision:
                    hr = m_Recorder()->get_ProductRevision(&str);
                    break;
                case BstrKind_ExclusiveAccessOwner:
                    hr = m_Recorder()->get_ExclusiveAccessOwner(&str);
                    break;
                default:
                    break;
                }
                if ( CheckRes(hr) )
                {
                    s = str;
                }
            }
            return s;
        }
        // PutRecorder 済み DiscFormat 作成
        template<typename TYP>
        void m_AdjustHandle(TYP& hp) const
        {
            if ( ! CheckRes(hp->put_Recorder(m_Recorder())) )
            {
                hp.Null();
            }
            else
            {
                CComBSTR s = _T("TnbImageMastering");
                if ( ! CheckRes(hp->put_ClientName(s)) )
                {
                    hp.Null();
                }
            }
        }
        // PutRecorder 済み DiscFormatData 作成
        CDiscFormatDataHandle m_CreateDiscFormatData(void) const
        {
            CDiscFormatDataHandle hp;
            if ( ! m_Recorder().IsNull() )
            {
                IDiscFormat2Data* P = NULL;
                if ( CheckRes(::CoCreateInstance(CLSID_MsftDiscFormat2Data, NULL, CLSCTX_ALL, IID_PPV_ARGS(&P))) )
                {
                    hp = P;
                    m_AdjustHandle(hp);
                }
            }
            return hp;
        }
        // PutRecorder 済み DiscFormatErase 作成
        CDiscFormatEraseHandle m_CreateDiscFormatErase(void) const
        {
            CDiscFormatEraseHandle hp;
            if ( ! m_Recorder().IsNull() )
            {
                IDiscFormat2Erase* P = NULL;
                if ( CheckRes(::CoCreateInstance(CLSID_MsftDiscFormat2Erase, NULL, CLSCTX_ALL, IID_PPV_ARGS(&P))) )
                {
                    hp = P;
                    m_AdjustHandle(hp);
                }
            }
            return hp;
        }
 
        //----
 
        #ifndef _TnbDOXYGEN //Document作成用シンボル
        
        CDiscRecorderHandle& m_Recorder(void) const
        {
            return m_member.hpRecorder;
        }
        CDiscFormatDataHandle& m_Writer(void) const
        {
            return m_member.hpWriter;
        }
        class CMyProgressData : public IListener::CProgressData
        {
        public:
            CMyProgressData(void) : m_elapsedTime(0), m_expectedTime(0)
                , m_startLba(0), m_sectorCount(0), m_lastWrittenLba(0)
            {}
            LONG GetRemainingTime(void) const { return m_expectedTime - m_elapsedTime; }
            LONG GetElapsedTime(void) const { return m_elapsedTime; }
            LONG GetExpectedTime(void) const { return m_expectedTime; }
            LONG GetStartLba(void) const { return m_startLba; }
            LONG GetTotalSectorCount(void) const { return m_sectorCount; }
            LONG GetWrittenLba(void) const { return m_lastWrittenLba; }
            LONG GetWrittenSector(void) const { return m_lastWrittenLba - m_startLba; }
            //
            LONG m_elapsedTime;         
            LONG m_expectedTime;        
            LONG m_startLba;            
            LONG m_sectorCount;         
            LONG m_lastWrittenLba;      
        };
        struct TMember : IImageMasteringWriterListener, IImageMasteringEraseListener
        {
            TMember(void) : pListener(NULL)
            {}
            //書き込みイベント
            virtual void OnWriterEvent(IDispatch* pObjectDisp, IDispatch* pProgressDisp)
            {
                if ( pListener == NULL ) { return; }
                IDiscFormat2DataEventArgs* pProgress = NULL;
                HRESULT hr = pProgressDisp->QueryInterface(IID_PPV_ARGS(&pProgress));
                if ( FAILED(hr) )
                {
                    pListener->OnDriveErrorResult(hr);
                    return;
                }
                IMAPI_FORMAT2_DATA_WRITE_ACTION currentAction = IMAPI_FORMAT2_DATA_WRITE_ACTION_VALIDATING_MEDIA;
                hr = pProgress->get_CurrentAction(&currentAction);
                if ( FAILED(hr) )
                {
                    pListener->OnDriveErrorResult(hr);
                    return;
                }
                CMyProgressData pd;
                pProgress->get_ElapsedTime(&pd.m_elapsedTime);
                pProgress->get_TotalTime(&pd.m_expectedTime);
                pProgress->get_StartLba(&pd.m_startLba);
                pProgress->get_SectorCount(&pd.m_sectorCount);
                pProgress->get_LastWrittenLba(&pd.m_lastWrittenLba);
                switch ( currentAction )
                {
                case IMAPI_FORMAT2_DATA_WRITE_ACTION_FINALIZATION:
                case IMAPI_FORMAT2_DATA_WRITE_ACTION_COMPLETED:
                    pd.m_elapsedTime = pd.m_expectedTime;
                    pd.m_lastWrittenLba = pd.m_startLba + pd.m_sectorCount;
                    break;
                default:
                    break;
                }
                if ( ! pListener->OnDriveWriteEvent(pd, currentAction) )
                {
                    hpWriter->CancelWrite();
                }
            }   
            //消去イベント
            virtual void OnEraseEvent(IDispatch* object, LONG elapsedSeconds, LONG expectedSeconds)
            {
                if ( pListener != NULL )
                {
                    CMyProgressData pd;
                    pd.m_elapsedTime = elapsedSeconds;
                    pd.m_expectedTime = expectedSeconds;
                    pListener->OnDriveEraseEvent(pd);
                }
            }
            IListener*              pListener;  
            CDiscRecorderHandle     hpRecorder; 
            CDiscFormatDataHandle   hpWriter;   
        };
        mutable TMember         m_member;       
 
        #endif //_TnbDOXYGEN
    };
 
 
    //------------------------------------------------
 
 
    CImageMastering(void)
    {
    }
 
    bool IsSupported(void) const
    {
        m_CheckInst();
        if ( ! m_hpDiscMaster.IsNull() )
        {
            VARIANT_BOOL b;
            HRESULT hr = m_hpDiscMaster->get_IsSupportedEnvironment(&b);
            if ( SUCCEEDED(hr) )
            {
                return b != 0;
            }
        }
        return false;
    }
 
    size_t GetDriveCount(void) const
    {
        m_CheckInst();
        if ( ! m_hpDiscMaster.IsNull() )
        {
            LONG cnt;
            HRESULT hr = m_hpDiscMaster->get_Count(&cnt);
            if ( SUCCEEDED(hr) )
            {
                return cnt;
            }
        }
        return 0;
    }
 
    CStr GetDriveName(INDEX index) const
    {
        CStr s;
        if ( GetDriveCount() > index )
        {
            CComBSTR str;
            HRESULT hr = m_hpDiscMaster->get_Item(index, &str);
            if ( SUCCEEDED(hr) )
            {
                s = str;
            }
        }
        return s;
    }
 
    CDrive CreateDrive(INDEX index) const
    {
        IDiscRecorder2* P = NULL;
        CheckRes(::CoCreateInstance(CLSID_MsftDiscRecorder2, NULL, CLSCTX_ALL, IID_PPV_ARGS(&P)));
        return CDrive(P, GetDriveName(index));
    }
 
    static CStr ToString(IMAPI_MEDIA_PHYSICAL_TYPE type)
    {
        const static CStaticMapT<IMAPI_MEDIA_PHYSICAL_TYPE,LPCTSTR> s_map[] = 
        {
            IMAPI_MEDIA_TYPE_UNKNOWN,               _T(""),
            IMAPI_MEDIA_TYPE_CDROM,                 _T("CD-ROM"),
            IMAPI_MEDIA_TYPE_CDR,                   _T("CD-R"),
            IMAPI_MEDIA_TYPE_CDRW,                  _T("CD-RW"),
            IMAPI_MEDIA_TYPE_DVDROM,                _T("DVD-ROM"),
            IMAPI_MEDIA_TYPE_DVDRAM,                _T("DVD-RAM"),
            IMAPI_MEDIA_TYPE_DVDPLUSR,              _T("DVD+R"),
            IMAPI_MEDIA_TYPE_DVDPLUSRW,             _T("DVD+RW"),
            IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER,    _T("DVD+R DL"),
            IMAPI_MEDIA_TYPE_DVDDASHR,              _T("DVD-R"),
            IMAPI_MEDIA_TYPE_DVDDASHRW,             _T("DVD-RW"),
            IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER,    _T("DVD-R DL"),
            IMAPI_MEDIA_TYPE_DISK,                  _T("DISK"),
            IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER,   _T("DVD+RW DL"),
            IMAPI_MEDIA_TYPE_HDDVDROM,              _T("HD DVD-ROM"),
            IMAPI_MEDIA_TYPE_HDDVDR,                _T("HD DVD-R"),
            IMAPI_MEDIA_TYPE_HDDVDRAM,              _T("HD DVD-RAM"),
            IMAPI_MEDIA_TYPE_BDROM,                 _T("BD-ROM"),
            IMAPI_MEDIA_TYPE_BDR,                   _T("BD-R"),
            IMAPI_MEDIA_TYPE_BDRE,                  _T("BD-RE"),
        };
        return CStaticMapT<IMAPI_MEDIA_PHYSICAL_TYPE, LPCTSTR>::Find(type, s_map);
    }
 
private:
    // インスタンスチェック.
    bool m_CheckInst(void) const
    {
        if ( m_hpDiscMaster.IsNull() )
        {
            IDiscMaster2* P = NULL;
            CheckRes(::CoCreateInstance(CLSID_MsftDiscMaster2, NULL, CLSCTX_ALL, IID_PPV_ARGS(&P)));
            m_hpDiscMaster = P;
        }
        return ! m_hpDiscMaster.IsNull();
    }
    mutable CDiscMasterHandle   m_hpDiscMaster;
};
 
 
 
}; //TNB
 
 
 
#ifdef _TnbDOXYGEN  //Document作成用シンボル
 
enum IMAPI_FORMAT2_DATA_WRITE_ACTION
{
    IMAPI_FORMAT2_DATA_WRITE_ACTION_VALIDATING_MEDIA,       
    IMAPI_FORMAT2_DATA_WRITE_ACTION_FORMATTING_MEDIA,       
    IMAPI_FORMAT2_DATA_WRITE_ACTION_INITIALIZING_HARDWARE,  
    IMAPI_FORMAT2_DATA_WRITE_ACTION_CALIBRATING_POWER,      
    IMAPI_FORMAT2_DATA_WRITE_ACTION_WRITING_DATA,           
    IMAPI_FORMAT2_DATA_WRITE_ACTION_FINALIZATION,           
    IMAPI_FORMAT2_DATA_WRITE_ACTION_COMPLETED,              
};
 
enum IMAPI_FORMAT2_DATA_MEDIA_STATE
{
    IMAPI_FORMAT2_DATA_MEDIA_STATE_OVERWRITE_ONLY   = 0x1,          
    IMAPI_FORMAT2_DATA_MEDIA_STATE_BLANK    = 0x2,                  
    IMAPI_FORMAT2_DATA_MEDIA_STATE_APPENDABLE   = 0x4,              
    IMAPI_FORMAT2_DATA_MEDIA_STATE_FINAL_SESSION    = 0x8,          
    IMAPI_FORMAT2_DATA_MEDIA_STATE_DAMAGED  = 0x400,                
    IMAPI_FORMAT2_DATA_MEDIA_STATE_ERASE_REQUIRED   = 0x800,        
    IMAPI_FORMAT2_DATA_MEDIA_STATE_NON_EMPTY_SESSION    = 0x1000,   
    IMAPI_FORMAT2_DATA_MEDIA_STATE_WRITE_PROTECTED  = 0x2000,       
    IMAPI_FORMAT2_DATA_MEDIA_STATE_FINALIZED    = 0x4000,           
    IMAPI_FORMAT2_DATA_MEDIA_STATE_UNSUPPORTED_MEDIA    = 0x8000    
};
 
enum IMAPI_MEDIA_PHYSICAL_TYPE
{
    IMAPI_MEDIA_TYPE_UNKNOWN,               
    IMAPI_MEDIA_TYPE_CDROM,                 
    IMAPI_MEDIA_TYPE_CDR,                   
    IMAPI_MEDIA_TYPE_CDRW,                  
    IMAPI_MEDIA_TYPE_DVDROM,                
    IMAPI_MEDIA_TYPE_DVDRAM,                
    IMAPI_MEDIA_TYPE_DVDPLUSR,              
    IMAPI_MEDIA_TYPE_DVDPLUSRW,             
    IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER,    
    IMAPI_MEDIA_TYPE_DVDDASHR,              
    IMAPI_MEDIA_TYPE_DVDDASHRW,             
    IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER,    
    IMAPI_MEDIA_TYPE_DISK,                  
    IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER,   
    IMAPI_MEDIA_TYPE_HDDVDROM,              
    IMAPI_MEDIA_TYPE_HDDVDR,                
    IMAPI_MEDIA_TYPE_HDDVDRAM,              
    IMAPI_MEDIA_TYPE_BDROM,                 
    IMAPI_MEDIA_TYPE_BDR,                   
    IMAPI_MEDIA_TYPE_BDRE,                  
};
 
#endif
 
 
#if 0
 
todo;
 
    When unlocking a recorder, the lock count must reach zero to free 
    the device for other clients. Calling the IDiscRecorder2::ReleaseExclusiveAccess 
    method decrements the lock count by one.
 
    An equal number of calls to the AcquireExclusiveAccess and 
    ReleaseExclusiveAccess methods are needed to free a device. 
    Should the application exit unexpectedly or crash while holding 
    the exclusive access, the CDROM.SYS driver will automatically 
    release these exclusive locks.
 
    If the device is already locked, you can call IDiscRecorder2::get_ExclusiveAccessOwner 
    to retrieve the name of the client application that currently has exclusive access.
 
todo;
 
    VC++6 、MFC で作成したダイアログ上で、書き込みしている時、
    フォーカス移動で、なぞの アクセスバイオレーション発生！
 
#endif