TnbPrimoBurnerEngine.h

[詳解]

#pragma once
#include "TnbFileFinder.h"
#include "TnbFileName.h"
#include "TnbStrVector.h"
#include "TnbTickCount.h"
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#if defined(___PRIMO_TCHAR_T) | defined(__PRIMO_CHAR_T)
 #error hpCDE.h will be included previously.
#endif
#define ___PRIMO_TCHAR_T
typedef wchar_t tchar_t;
#define ___PRIMO_CHAR_T
typedef wchar_t char_t;
 
// 以下のPathを通すこと
#ifdef __MSVCPP6__
    #define deprecated dllexport
    #include "hpCDE.h"
    #undef deprecated
#else
    #include "hpCDE.h"
#endif
#pragma comment(lib,"hpCDEU.lib")
#pragma comment(lib,"DataCDU.lib")
 
#ifdef ___HPSCSI_H___
    // PrimoBurner 2.10以降を使用
    #define _TnbPrimoBurner_Used_V2
#else
    // PrimoBurner 2.00以降を使用
    #pragma comment(lib,"HfsU.lib")
#endif
 
#endif // _TnbDOXYGEN
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#define PRIBUR ::primo::burner
#ifdef _TnbPrimoBurner_Used_V2
 #define PRISCSI ::primo::scsi
#else
 #define PRISCSI ::primo::burner
#endif
 
 
 
class CPrimoBurner : CCopyImpossible
{
public:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    // PointerHandleBase用 汎用 ポインタリリーステンプレートクラス
    template<typename T> struct TPhReleasePointerT
    {
        void operator()(T P) { P->Release(); }
    };
 
    #endif // _TnbDOXYGEN
 
 
    class CDiscImage
    {
    public:
 
        struct IListener
        {
            virtual ~IListener(void) {}
 
            virtual void OnFileStatus(int nFile, LPCWSTR lpszFileName, int nPercent) = 0;
        };
 
        CDiscImage(void) : m_hpDataDisc(hpCDE::CreateDataDisc()), m_hpDataFile(hpCDE::CreateDataFile())
        {        
            m_hpDataFile->SetDirectory(TRUE);       // Rootを設定しておく
            m_hpDataFile->SetFilePath(L"\\");           
            m_hpDataFile->SetLongFilename(L"\\");
        }
 
        ~CDiscImage(void)
        {
        }
 
        void SetListener(IListener* I)
        {
            m_callbacker.SetListener(I);
        }
 
        PRIBUR::IDataDisc* operator->(void)
        {
            return m_hpDataDisc;
        }
 
        DWORD GetLastError(void)
        {
            return m_hpDataDisc.IsNull() ? 0 : m_hpDataDisc->GetLastError();
        }
 
        void SetDefaultParametersForCd(LPCTSTR lpszVolume, EImageType eType = IMG_TYPE_JOLIET, DWORD dwFlags = IC_NONE)
        {
            m_hpDataDisc->SetVolumeLabel(CUnicode(lpszVolume));
            m_hpDataDisc->SetImageType(eType);
            m_hpDataDisc->SetImageConstraints(dwFlags);
            m_hpDataDisc->SetTranslateFilenames(false);
            SetBootableParameters(false);
            m_hpDataDisc->SetSessionStartAddress(0);
        }
 
        void SetDefaultParametersForDvd(LPCTSTR lpszVolume, EImageType eType = IMG_TYPE_UDF)
        {
            SetDefaultParametersForCd(lpszVolume, eType);
        }
 
        void SetBootableParameters(
                        bool boIsBootableCd, EBootEmulation eEmu = BMT_NO_EMULATION, LPCTSTR lpszbootImageFile = NULL)
        {
            m_hpDataDisc->SetBootable(boIsBootableCd);
            m_hpDataDisc->SetBootEmulation(eEmu);
            m_hpDataDisc->SetBootImageFile(CUnicode(lpszbootImageFile));
        }
 
        void ResetFileImage(void)
        {
            m_SetLayout(false);
        }
 
        bool AddSource(LPCTSTR lpszName, LPCTSTR lpszImagePath = NULL)
        {
            CAppendFile a(lpszName);
            return m_SetLayout(a.Execute(m_hpDataFile, m_hpDataDisc->GetImageType(), lpszImagePath));
        }
 
        bool AddSourceFromPath(LPCTSTR lpszName, LPCTSTR lpszImagePath = NULL)
        {
            CAppendPath a(lpszName);
            return m_SetLayout(a.Execute(m_hpDataFile, m_hpDataDisc->GetImageType(), lpszImagePath));
        }
 
        bool CreateImageFile(LPCTSTR lpszFile)
        {
            m_hpDataDisc->SetCallback14(&m_callbacker);
            CUnicode s = CUnicode(lpszFile);
            s.Replace(L"\\\\", L"\\");
            bool r = !! m_hpDataDisc->CreateImageFile(s);
            if ( ! r )
            {
                TRACE1("err - %d\n", m_hpDataDisc->GetLastError() - SCSI_SENSE_ERROR_BASE );
                TRACE1("err - %d\n", GetLastError() );
            }
            m_SetLayout(true);
            return r;
        }
 
    private:
 
        #ifndef _TnbDOXYGEN //Document作成用シンボル
 
        class CCallBacker : public PRIBUR::IDataDiscCallback14
        {
            IListener*  m_iListener;
        public:
            CCallBacker(void) : m_iListener(NULL) {}
            virtual ~CCallBacker(void) {}
            void SetListener(IListener* I)
            {
                m_iListener = I;
            }
            virtual void OnFileStatus(int nFile, const tchar_t* pFileName, int nPercent) 
            {
                nPercent = (nPercent > 100) ? 100 : nPercent;
                TRACE3("No.%d %d%% [%s] \n", nFile, nPercent, CStr(pFileName));
                if ( m_iListener != NULL )
                {
                    m_iListener->OnFileStatus(nFile, pFileName, nPercent);
                }
            }
            virtual bool_t OnContinueBurn(void) { return true; }
            virtual void OnProgress(uint64_t ddwPos, uint64_t ddwAll) {}
            virtual void OnStatus(EDataDiscStatus eStatus) {}
        };
 
        typedef CPointerHandleBaseT<PRIBUR::IDataDisc*, TPhReleasePointerT<PRIBUR::IDataDisc*> > CDataDiscHandle;
        typedef CPointerHandleBaseT<PRIBUR::IDataFile*, TPhReleasePointerT<PRIBUR::IDataFile*> > CDataFileHandle;
        CDataDiscHandle         m_hpDataDisc;   
        CDataFileHandle         m_hpDataFile;   
        CCallBacker             m_callbacker;   
 
        struct TFileInfo
        {
            CStr        strFileName;                
            CStr        strAlternateFileName;       
            bool        boHasHidden;                
            CFileTimeEx timeLastWrite;              
            TFileInfo(void) {}
            TFileInfo(const WIN32_FIND_DATA& fd) {
                Set(fd);
            }
            void Set(const WIN32_FIND_DATA& fd) {
                strFileName             = fd.cFileName;
                strAlternateFileName    = fd.cAlternateFileName;
                boHasHidden             = (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0;
                timeLastWrite           = fd.ftLastWriteTime;
            }
            CStr GetFileName(void) const {
                return strFileName;
            }
            CStr GetAlternateFileName(void) const {
                return strAlternateFileName.Left(12);
            }
            FILETIME GetFileTime(void) const {
                return timeLastWrite;
            }
        };
 
        class CAbstractAppender
        {
            bool m_Dig(const CDataFileHandle& hpFile, DWORD dwImageType, const CStr& strImagePath)
            {
                if ( strImagePath.IsEmpty() )
                {
                    return OnFound(hpFile, dwImageType);
                }
                CStr s1 = strImagePath;
                CStr s2;
                int f = strImagePath.Find(_T('\\'));
                if ( f < 0 ) { f = strImagePath.Find(_T('/')); }
                if ( f >= 0 )
                {
                    s1 = strImagePath.Left(f);
                    s2 = strImagePath.Mid(f + 1);
                    if ( s1.IsEmpty() )
                    {
                        return m_Dig(hpFile, dwImageType, s2);
                    }
                }
                CDataFileHandle F = hpFile->Find(CUnicode(_T("/") + s1));
                if ( F.IsNull() )
                {
                    F = hpCDE::CreateDataFile(); 
                    TFileInfo fd;
                    fd.boHasHidden          = false;
                    fd.strAlternateFileName = s1;
                    fd.strFileName          = s1;
                    fd.timeLastWrite        = CFileTimeEx::GetCurrent();
                    SetDataFile(F, true, s1, dwImageType, fd);
                    if ( ! m_Dig(F, dwImageType, s2) )
                    {
                        return false;
                    }
                    hpFile->AddItem(F);
                }
                else
                {
                    if ( ! m_Dig(F, dwImageType, s2) )
                    {
                        return false;
                    }
                }
                return true;
            }
        public:
            virtual bool OnSetup(void) = 0;
            virtual bool OnFound(const CDataFileHandle& hpFile, DWORD dwImageType) = 0;
            bool Execute(const CDataFileHandle& hpFile, DWORD dwImageType, LPCTSTR lpszImagePath)
            {
                if ( ! OnSetup() ) { return false; }
                CStr str = lpszImagePath;
                return m_Dig(hpFile, dwImageType, str);
            }
            static void SetDataFile(
                    PRIBUR::IDataFile* _pFile, bool boDir, LPCTSTR lpszFilePath, DWORD dwImageType, const TFileInfo& fd)
            {
                _pFile->SetDirectory(boDir);
                _pFile->SetFilePath(CUnicode(lpszFilePath));            
                _pFile->SetLongFilename(CUnicode(fd.GetFileName()));
                _pFile->SetShortFilename(CUnicode(fd.GetAlternateFileName()));
                _pFile->SetHiddenAttribute(static_cast<EImageType>(dwImageType), fd.boHasHidden);
                #ifdef _TnbPrimoBurner_Used_V2
                    FILETIME ft = fd.GetFileTime();
                    _pFile->SetCreationTime(&ft);
                #else
                    _pFile->SetFileTime(&fd.GetFileTime());
                #endif
            }
        };
 
        class CAppendFile : public CAbstractAppender
        {
            DEFSUPER(CAbstractAppender);
            CStr        m_strFullPath;
            TFileInfo   m_fileInfo;
        public:
            CAppendFile(LPCTSTR lpszFullPath) : m_strFullPath(lpszFullPath) {}
            virtual bool OnSetup(void)
            {
                CFileName fn(m_strFullPath);
                if ( ! fn.IsExist() || fn.IsDirectory() )
                {
                    return false;
                }
                m_fileInfo.boHasHidden          = fn.IsHidden();
                m_fileInfo.timeLastWrite        = fn.GetLastWriteTime();
                m_fileInfo.strAlternateFileName = fn.GetShortName();
                m_fileInfo.strFileName          = fn.GetFileName();
                m_strFullPath = fn;
                return true;
            }
            virtual bool OnFound(const CDataFileHandle& hpFile, DWORD dwImageType)
            {
                CDataFileHandle F = hpCDE::CreateDataFile(); 
                SetDataFile(F, false, m_strFullPath, dwImageType, m_fileInfo);
                hpFile->AddItem(F);
                return true;
            }
        };
 
        class CAppendPath : public CAbstractAppender
        {
            DEFSUPER(CAbstractAppender);
            CStr        m_strPath;
            bool m_AddTree(PRIBUR::IDataFile* pFile, DWORD dwImageType, LPCTSTR lpszPath)
            {
                CFileFinder ff;
                if ( ff.Start(lpszPath, _T("\\*")) )
                {
                    do
                    {
                        CStr strFileName = ff->cFileName; 
                        CStr strFullPath;
                        strFullPath.Format(_T("%s\\%s"), lpszPath, strFileName);
                        if ( (ff->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 )
                        {
                            // Dir
                            CDataFileHandle F = pFile->Find(CUnicode(_T("/") + strFileName));
                            if ( F.IsNull() )
                            {
                                F = hpCDE::CreateDataFile(); 
                                _super::SetDataFile(F, true, strFileName, dwImageType, TFileInfo(ff.Get()));
                                if ( ! m_AddTree(F, dwImageType, strFullPath) )
                                {
                                    return false;
                                }
                                pFile->AddItem(F);
                            }
                            else
                            {
                                if ( ! m_AddTree(F, dwImageType, strFullPath) )
                                {
                                    return false;
                                }
                            }
                        } 
                        else
                        {
                            // File
                            CDataFileHandle F = hpCDE::CreateDataFile(); 
                            _super::SetDataFile(F, false, strFullPath, dwImageType, TFileInfo(ff.Get()));
                            pFile->AddItem(F);
                        }
                    } while ( ff.Next() );
                }
                return true;
            }
        public:
            CAppendPath(LPCTSTR lpszPath) : m_strPath(lpszPath) {}
            virtual bool OnSetup(void)
            {
                CFileFinder ff;
                return ff.Start(m_strPath, _T("\\*"));
            }
            virtual bool OnFound(const CDataFileHandle& hpFile, DWORD dwImageType)
            {
                return m_AddTree(hpFile, dwImageType, m_strPath);
            }
        };
 
        #endif //_TnbDOXYGEN
 
        bool m_SetLayout(bool boIsSet)
        {
            try
            {
                if ( boIsSet && m_hpDataDisc->SetImageLayout11(m_hpDataFile) )
                {
                    return true;
                }
                m_hpDataFile = hpCDE::CreateDataFile(); 
                m_hpDataFile->SetDirectory(TRUE);       //ルートを設定しておく
                m_hpDataFile->SetFilePath(L"\\");           
                m_hpDataFile->SetLongFilename(L"\\");
                m_hpDataDisc->SetImageLayout11(m_hpDataFile);
            }
            catch(PRIBUR::EDataDiscError& error)
            {
                IgnoreUnusedValue(error);
            }
            return false;
        }
    };
 
 
 
    class CScsi
    {
    public:
 
        CScsi(PRISCSI::IScsiInterface* P = NULL) : m_hpScsi(P)
        {
        }
 
        ~CScsi(void)
        {
        }
 
        bool IsValid(void) const
        {
            return ! m_hpScsi.IsNull();
        }
 
        bool SendCommand(const ISequenceCollectionT<BYTE>& cdb, DWORD dwTimeout = SCSI_CMD_TIMEOUT_MS_LONG)
        {
            if ( m_hpScsi.IsNull() ) { return false; }
            return !! m_hpScsi->SendCommand(cdb.ReferBuffer(), cdb.GetSize(), SCSI_CMD_DIR_UNSPECIFIED, NULL, 0, dwTimeout);
        }
 
        CByteVector SendCommandWithReadPhase(
                        const ISequenceCollectionT<BYTE>& cdb, int iReadSize, DWORD dwTimeout = SCSI_CMD_TIMEOUT_MS_LONG)
        {
            CByteVector vb;
            if ( ! m_hpScsi.IsNull() ) 
            {
                bool r = !! m_hpScsi->SendCommand(
                            cdb.ReferBuffer(), cdb.GetSize(), SCSI_CMD_DIR_READ, vb.GetBuffer(iReadSize), iReadSize, dwTimeout);
                vb.ReleaseBuffer();
                if ( r )
                {
                    return vb;
                }
            }   
            vb.Invalid();
            return vb; 
        }
 
        bool SendCommandWithWritePhase(
                const ISequenceCollectionT<BYTE>& cdb, const ISequenceCollectionT<BYTE>& d, DWORD dwTimeout = SCSI_CMD_TIMEOUT_MS_LONG)
        {
            if ( m_hpScsi.IsNull() ) { return false; }
            return !! m_hpScsi->SendCommand(
                        cdb.ReferBuffer(), cdb.GetSize(), SCSI_CMD_DIR_WRITE, const_cast<BYTE*>(d.ReferBuffer()), d.GetSize(), dwTimeout);
        }
 
        CByteVector Send_ModeSense(BYTE pc, bool boIsDbd = false, DWORD dwTimeout = SCSI_CMD_TIMEOUT_MS_LONG)
        {
            CByteVector cdb;
            cdb.SetSize(6);
            cdb[0] = 0x1A;  //ModeSense
            cdb[1] = _BIT(3); //Block Descriptor は転送なし。
            cdb[2] = pc;
            cdb[4] = 4;
            CByteVector r = SendCommandWithReadPhase(cdb, cdb[4], dwTimeout);
            if ( r.GetSize() != 4 )
            {
                return r;
            }
            cdb[1] = static_cast<BYTE>((boIsDbd && r[3] == 8) ? 0 : _BIT(3));
            cdb[4] = static_cast<BYTE>(4 + r[3] + r[0]);
            return SendCommandWithReadPhase(cdb, cdb[4], dwTimeout);
        }
 
        CByteVector Send_Inquiry(DWORD dwTimeout = SCSI_CMD_TIMEOUT_MS_LONG)
        {
            CByteVector cdb;
            cdb.SetSize(6);
            cdb[0] = 0x12;  //Inquiry
            cdb[4] = 8;
            CByteVector r = SendCommandWithReadPhase(cdb, cdb[4], dwTimeout);
            if ( r.GetSize() != 8 )
            {
                return r;
            }
            cdb[4] = static_cast<BYTE>(5 + r[4]);
            return SendCommandWithReadPhase(cdb, cdb[4], dwTimeout);
        }
 
        DWORD GetLastError(void)
        {
            return m_hpScsi.IsNull() ? 0 : m_hpScsi->GetLastError();
        }
 
        DWORD GetLastSystemError(void)
        {
            return m_hpScsi.IsNull() ? 0 : m_hpScsi->GetLastSystemError();
        }
 
        bool GetSense(PRISCSI::SCSI_COMMAND_SENSE& _sense)
        {
            if ( m_hpScsi.IsNull() ) { return false; }
            m_hpScsi->GetSense(&_sense);
            return true;
        }
 
    private:
        typedef CPointerHandleBaseT<PRISCSI::IScsiInterface*, TPhReleasePointerT<PRISCSI::IScsiInterface*> > CScsiHandle;
        CScsiHandle     m_hpScsi;       
    };
 
 
    
    class CDevice
    {
    public:
 
        struct IListener
        {
            enum EType
            {
                BURN,           
                FORMAT,         
                WRITELEADIN,    
                WRITELEADOUT,   
            };
 
            virtual ~IListener(void) {}
 
            virtual void OnProgress(EType eType, ULONGLONG ullPos, ULONGLONG ullAll) = 0;
 
            virtual void OnStatus(PRIBUR::EDataDiscStatus eStatus) = 0;
        
            virtual void OnFileStatus(int nFile, LPCWSTR lpszFileName, int nPercent) = 0;
 
            virtual bool OnContinueBurn() = 0;
        };
 
        CDevice(PRIBUR::IDevice* P = NULL) 
                : m_hpDevice(P), m_dwWriteSpeed(0), m_boIsEject(true)
        {
        }
 
        ~CDevice(void)
        {
        }
 
        void SetListener(IListener* I)
        {
            m_callbacker.SetListener(I);
        }
 
        void SetEjectMode(bool boIsEject)
        {
            m_boIsEject = boIsEject;
        }
 
        void Close(void)
        {
            m_hpDevice.Null();
        }
 
        bool IsValid(void) const
        {
            return ! m_hpDevice.IsNull();
        }
 
        DWORD GetLastError(void)
        {
            return m_hpDevice.IsNull() ? 0 : m_hpDevice->GetLastError();
        }
 
        PRIBUR::IDevice* operator->(void)
        {
            return m_hpDevice;
        }
 
        CScsi CreateScsi(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return CScsi();
            }
            return CScsi(m_hpDevice->GetScsiInterface());
        }
 
        bool IsMediaReady(DWORD dwTime = 0)
        {
            if ( m_hpDevice.IsNull() )
            {
                return false;
            }
            if ( dwTime == 0 )
            {
                return m_hpDevice->GetUnitReady() == DEVICE_ERROR_SUCCESS;
            }
            CTickCount tick;
            while ( ! tick.IsPassed(dwTime) )
            {
                if ( m_hpDevice->GetUnitReady() == DEVICE_ERROR_SUCCESS )
                {
                    return true;
                }
                ::Sleep(100);
            }
            return false;
        }
        
        DWORD GetMediaFreeByte(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return 0;
            }
            return m_hpDevice->GetMediaFreeSpace() * CDROM_BLOCKSIZE;
        }
 
        bool HasWritableMedia(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return false;
            }
            TRACE3("HasWritableMedia()  %d,%d,%d\n", 
                    m_hpDevice->GetMediaFreeSpace(), m_hpDevice->GetReWritePossible(), m_hpDevice->GetMediaIsReWritable());
            if ( m_hpDevice->GetMediaFreeSpace() == 0 )
            {
                return false;
            }
            return m_hpDevice->GetReWritePossible() && m_hpDevice->GetMediaIsReWritable();
        }
 
        bool HasRewritableMedia(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return false;
            }
            TRACE2("HasRewritableMedia()  %d,%d\n", m_hpDevice->GetReWritePossible(), m_hpDevice->GetMediaIsReWritable());
            return m_hpDevice->GetReWritePossible() && m_hpDevice->GetMediaIsReWritable();
        }
 
        PRIBUR::EMediaProfile GetMediaProfile(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return MP_UNKNOWN;
            }
            return m_hpDevice->GetMediaProfile();
        }
 
        static CStr ToString(PRIBUR::EMediaProfile e)
        {
            CStr s;
            switch ( e )
            {
            default:
            case MP_UNKNOWN:    break;
            case MP_CD_ROM:             s = _T("CD-ROM");   break;
            case MP_CD_R:               s = _T("CD-R");     break;
            case MP_CD_RW:              s = _T("CD-RW");    break;
            case MP_DVD_ROM:            s = _T("DVD-ROM");  break;
            case MP_DVD_MINUS_R_SEQ:    s = _T("DVD-R");    break;
            case MP_DVD_RAM_RW:         s = _T("DVD-RAM");  break;
            case MP_DVD_MINUS_RW_RO: //DVD-RW Restricted Overwrite -- Re-writable DVD formatted for restricted overwrite recording.
            case MP_DVD_MINUS_RW_SEQ: //DVD-RW Sequential Recording -- Re-writable DVD that can be recorded only sequentially.
                                        s = _T("DVD-RW");   break;
            case MP_DVD_MINUS_R_DL_SEQ: //DVD-R DL -- Write once DVD-R Double Layer 8.5GB that can be recorded sequentially.
            case MP_DVD_MINUS_R_DL_JUMP: //DVD-R DL -- Write once DVD-R Double Layer 8.5GB that can be recorded using layer jumping.
                                        s = _T("DVD-R DL"); break;
            case MP_DVD_PLUS_RW:        s = _T("DVD+RW"); break;
            case MP_DVD_PLUS_R:         s = _T("DVD+R"); break;
            case MP_DVD_PLUS_R_DL:      s = _T("DVD+R DL"); break;
            #ifdef _TnbPrimoBurner_Used_V2
            case MP_BD_R_SRM:
            case MP_BD_R_SRM_POW:
            case MP_BD_R_RRM:           s = _T("BD-R"); break;
            case MP_BD_RE:              s = _T("BD-RE"); break;
            #endif
            }
            return s;
        }
 
        CDwordVector GetSpeeds(void)
        {
            CDwordVector vdwSpeeds;
            if ( ! m_hpDevice.IsNull() )
            {
                PRIBUR::ISpeedCollection* pSpeeds = m_hpDevice->GetSupportedWriteSpeeds();
                loop ( i, pSpeeds->GetCount() )
                {
                    PRIBUR::ISpeedDescriptor* pSpeed = pSpeeds->GetItem(i);
                    vdwSpeeds.Add(pSpeed->GetTransferRateKB());
                    pSpeed->Release();
                }
                pSpeeds->Release();
            }
            return vdwSpeeds;
        }
 
        int GetLastCompleteTrack(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return -1;
            }
            int nLastTrack = 0;
            PRIBUR::EMediaProfile mp = m_hpDevice->GetMediaProfile();
            if ( MP_DVD_PLUS_RW == mp || MP_DVD_MINUS_RW_RO == mp )
            {
                // DVD+RW and DVD-RW RO has only one session with one track
                if ( m_hpDevice->GetMediaFreeSpace() > 0 )
                {
                    nLastTrack = 1; 
                }
            }       
            else
            {
                PRIBUR::READDISKINFO di;
                if ( m_hpDevice->ReadDiskInfo(&di) )
                {
                    nLastTrack = di.wLastTrack;
                    if ( DISK_STATUS_OPEN == di.eDiskStatus || DISK_STATUS_EMPTY == di.eDiskStatus )
                    {
                        nLastTrack--;
                    }
                }
            }
            return nLastTrack;
        }
 
        static double Get1xSpeed(bool boIsDvd)
        {
            return boIsDvd ? SPEED_DVD_1X_KB : SPEED_CD_1X_KB;
        }
        
        DWORD GetWriteSpeed(void)
        {
            if ( m_hpDevice.IsNull() )
            {
                return 0;
            }
            if ( m_dwWriteSpeed == 0 )
            {
                return m_hpDevice->GetMaxWriteSpeedKB();
            }
            return m_dwWriteSpeed;
        }
 
        void SetWriteSpeed(DWORD dw)
        {
            m_dwWriteSpeed = dw;
        }
 
        bool Erase(EEraseType eType = ERASE_DISC)
        {
            if ( m_hpDevice.IsNull() )
            {
                return false;
            }
            PRIBUR::EMediaProfile mp = m_hpDevice->GetMediaProfile();
            if ( MP_DVD_MINUS_RW_SEQ != mp && MP_DVD_MINUS_RW_RO != mp && MP_CD_RW != mp )
            {
                //AfxMessageBox(_T("Erasing is supported on CD-RW and DVD-RW media only."), MB_OK);
                return false;
            }
            m_hpDevice->SetCallback13(&m_callbacker);
            m_hpDevice->SetCallback15(&m_callbacker);
            bool r = !! m_hpDevice->Erase13(eType);
            if ( m_boIsEject )
            {
                m_hpDevice->Eject(TRUE);
            }
            return r;
        }
 
        bool Format(bool boIsQuick = false)
        {
            if ( m_hpDevice.IsNull() )
            {
                return false;
            }
            PRIBUR::EMediaProfile mp = m_hpDevice->GetMediaProfile();
            m_hpDevice->SetCallback13(&m_callbacker);
            m_hpDevice->SetCallback15(&m_callbacker);
            BOOL bRes = TRUE;
            switch ( mp )
            {
            case MP_CD_RW:
                bRes = !! m_hpDevice->Erase13(boIsQuick ? ERASE_MINIMAL : ERASE_DISC);
                break;
            case MP_DVD_MINUS_RW_RO:
            case MP_DVD_MINUS_RW_SEQ:
                bRes = m_hpDevice->Format(boIsQuick ? FT_DVD_MINUS_RW_QUICK : FT_DVD_MINUS_RW_FULL);
                break;
            case MP_DVD_PLUS_RW:
                switch ( m_hpDevice->GetBgFormatStatus() )
                {
                case BFS_NOT_FORMATTED:
                    bRes = m_hpDevice->Format(FT_DVD_PLUS_RW_FULL, 0, false);
                    break;
                case BFS_PARTIAL:
                    bRes = m_hpDevice->Format(FT_DVD_PLUS_RW_RESTART, 0, false);
                    break;
                default:
                    return false;
                    break;
                }
                break;
            default:
                return false;
                break;
            }
            if ( m_boIsEject )
            {
                m_hpDevice->Eject(TRUE);
            }
            return !! bRes;
        }
 
        bool BurnImageFile(LPCTSTR lpszFile)
        {
            CDiscImage hpDataDisc;
            if ( ! m_PreBurn(hpDataDisc.operator->()) )
            {
                return false;
            }
            m_hpDevice->SetCallback13(&m_callbacker);
            m_hpDevice->SetCallback15(&m_callbacker);
            hpDataDisc->SetCallback14(&m_callbacker);
            bool r = !! hpDataDisc->WriteImageToDisc(CUnicode(lpszFile));
            if ( m_boIsEject )
            {
                m_hpDevice->Eject(TRUE);
            }
            return r;
        }
 
        bool Burn(CDiscImage& dd) 
        {
            PRIBUR::IDataDisc* pDataDisc = dd.operator->(); 
            if ( ! m_PreBurn(pDataDisc) )
            {
                return false;
            }
            m_hpDevice->SetCallback13(&m_callbacker);
            m_hpDevice->SetCallback15(&m_callbacker);
            pDataDisc->SetCallback14(&m_callbacker);
            bool r = true;
            while ( true )
            {
                if ( ! pDataDisc->WriteToDisc(TRUE) )
                {
                    if ( DATACD_ERROR_CANNOT_LOAD_IMAGE_LAYOUT == pDataDisc->GetLastError() )
                    {
                        pDataDisc->SetLoadTrackLayout(0);
                        continue;
                    }
                    else
                    {
                        r = false;
                    }
                }
                break;
            }
            pDataDisc->SetCallback14(NULL);
            if ( m_boIsEject )
            {
                m_hpDevice->Eject(TRUE);
            }
            return r;
        }
 
    private:
 
        #ifndef _TnbDOXYGEN
 
        class CCallBacker : public PRIBUR::IDeviceCallback13, public PRIBUR::IDeviceCallback15, public PRIBUR::IDataDiscCallback14
        {
            IListener*  m_iListener;
        public:
            CCallBacker(void) : m_iListener(NULL) {}
            virtual ~CCallBacker(void) {}
            void SetListener(IListener* I)
            {
                m_iListener = I;
            }
            virtual void OnProgress(uint64_t ddwPos, uint64_t ddwAll) 
            {
                TRACE3("OnProgress(%I64u,%I64u)  %f%%\n", ddwPos, ddwAll, (double)(LONGLONG)((ddwPos * 100) / ddwAll) );
                if ( m_iListener != NULL )
                {
                    m_iListener->OnProgress(IListener::BURN, ddwPos, ddwAll);
                }
            }
            virtual void OnStatus(PRIBUR::EDataDiscStatus eStatus) 
            {
                TRACE1("OnStatus(%d)\n", eStatus);
                if ( m_iListener != NULL )
                {
                    m_iListener->OnStatus(eStatus);
                }
            }
            virtual void OnFileStatus(int nFile, const tchar_t* pFileName, int nPercent) 
            {
                nPercent = nPercent > 100 ? 100 : nPercent;
                TRACE3("No.%d %d%% [%s] \n", nFile, nPercent, CStr(pFileName));
                if ( m_iListener != NULL )
                {
                    m_iListener->OnFileStatus(nFile, pFileName, nPercent);
                }
            }
            virtual bool_t OnContinueBurn() 
            {
                TRACE0("OnContinueBurn()\n");
                if ( m_iListener != NULL )
                {
                    return m_iListener->OnContinueBurn();
                }
                return true; 
            }
            virtual void OnFormatProgress(double doProgress)
            {
                TRACE1("OnFormatProgress(%f%%)\n", doProgress);
                if ( m_iListener != NULL )
                {
                    m_iListener->OnProgress(IListener::FORMAT, static_cast<DWORD>(doProgress) * 100, 10000);
                }
            }
            virtual void OnEraseProgress(double doProgress) 
            {
                TRACE1("OnEraseProgress(%f%%)\n", doProgress);
                if ( m_iListener != NULL )
                {
                    m_iListener->OnProgress(IListener::FORMAT, static_cast<DWORD>(doProgress * 100), 10000);
                }
            }
            virtual void OnWriteLeadIn(uint32_t dwBlocks, uint32_t dwAllBlocks) 
            {
                TRACE2("OnWriteLeadIn(%u,%u)\n", dwBlocks, dwAllBlocks);
                if ( m_iListener != NULL )
                {
                    m_iListener->OnProgress(IListener::WRITELEADIN, dwBlocks, dwAllBlocks);
                }
            }
            virtual void OnWriteLeadOut(uint32_t dwBlocks, uint32_t dwAllBlocks) 
            {
                TRACE2("OnWriteLeadOut(%u,%u)\n", dwBlocks, dwAllBlocks);
                if ( m_iListener != NULL )
                {
                    m_iListener->OnProgress(IListener::WRITELEADOUT, dwBlocks, dwAllBlocks);
                }
            }
        };
 
        #endif _TnbDOXYGEN
 
        typedef CPointerHandleBaseT<PRIBUR::IDevice*, TPhReleasePointerT<PRIBUR::IDevice*> > CDeviceHandle;
        CDeviceHandle       m_hpDevice;     
        DWORD               m_dwWriteSpeed; 
        bool                m_boIsEject;    
        CCallBacker         m_callbacker;   
 
        bool m_PreBurn(PRIBUR::IDataDisc * pDataDisc) 
        {
            if ( pDataDisc == NULL || m_hpDevice.IsNull() )
            {
                return false;
            }
            m_hpDevice->SetWriteSpeedKB(GetWriteSpeed());
            pDataDisc->SetDevice(m_hpDevice);
            EMediaProfile mp = m_hpDevice->GetMediaProfile();
            if ( mp == MP_DVD_PLUS_RW )
            {
                switch ( m_hpDevice->GetBgFormatStatus() )
                {
                case BFS_NOT_FORMATTED:
                    m_hpDevice->Format(FT_DVD_PLUS_RW_FULL);
                    break;
                case BFS_PARTIAL:
                    m_hpDevice->Format(FT_DVD_PLUS_RW_RESTART);
                    break;
                }
            }
            pDataDisc->SetCallback14(&m_callbacker);
            if ( mp == MP_CD_ROM || mp == MP_CD_R || mp == MP_CD_RW )
            {
                pDataDisc->SetSessionStartAddress(m_hpDevice->GetNewSessionStartAddress());
                pDataDisc->SetCacheSmallFiles(FALSE);
    //          pDataDisc->SetCacheSmallFiles(m_ctx.bCacheSmallFiles);
    //          if (m_ctx.bCacheSmallFiles) 
    //          {
    //              pDataDisc->SetSmallFileSizeThreshold(m_ctx.dwSmallFileSize);
    //              pDataDisc->SetSmallFilesCacheSize(m_ctx.dwSmallFilesCacheLimit);
    //          }
                // Set write mode
                pDataDisc->SetWriteMethod(WRITE_METHOD_TAO);
    //          if (!m_ctx.bRaw && (0 == m_ctx.nMode || 1 == m_ctx.nMode))
    //              // Session-At-Once (also called Disc-At-Once)
    //              pDataDisc->SetWriteMethod(WRITE_METHOD_SAO);
    //          else if (m_ctx.bRaw)
    //              // RAW Disc-At-Once
    //              pDataDisc->SetWriteMethod(WRITE_METHOD_RAW_DAO);
    //          else if (2 == m_ctx.nMode)
    //              // Track-At-Once
    //              pDataDisc->SetWriteMethod(WRITE_METHOD_TAO);
    //          else
    //              // Packet
    //              pDataDisc->SetWriteMethod(WRITE_METHOD_PACKET);
            }
            else
            {
                pDataDisc->SetCacheSmallFiles(FALSE);
                // Set write mode
                pDataDisc->SetWriteMethod(WRITE_METHOD_DVD_INCR);
    //          if (0 == m_ctx.nMode)
    //              // DVD Disc-At-Once
    //              pDataDisc->SetWriteMethod(WRITE_METHOD_DVD_DAO);
    //          else if (1 == m_ctx.nMode)
    //              // DVD Incremental
    //              pDataDisc->SetWriteMethod(WRITE_METHOD_DVD_INCR);
            }
    //      pDataDisc->SetSimulateBurn(m_ctx.bSimulate);
            pDataDisc->SetSimulateBurn(FALSE);
    //      pDataDisc->SetCloseDisk(m_ctx.bCloseDisk);
            pDataDisc->SetCloseDisk(TRUE);
            return true;
        }
    };
    
 
    //-----------------------------------------
 
    
    CPrimoBurner(void) : m_pEngine(NULL), m_pEnumerator(NULL), m_iDeviceNumber(0)
    {
    }
 
    ~CPrimoBurner(void)
    {
        m_CloseEnumerator();
        if ( m_pEngine != NULL )
        {
            m_pEngine->Shutdown();
            m_pEngine->Release();
            m_pEngine = NULL;
        }
    }
 
    int Initialize(bool boIsWritableOnly = true)
    {
        if ( ! m_InitEngine() )
        {
            return -1;
        }
        m_vDeviceNames.RemoveAll();
        m_CloseEnumerator();
        m_pEnumerator = m_pEngine->GetDevices();
        int iCount = m_pEnumerator->GetCount();
        if ( iCount <= 0 ) 
        {
            m_CloseEnumerator();
            return -1;
        }
        m_vDeviceNames.SetSize(iCount);
        int r = 0;
        for ( int i = 0; i < iCount; i++ ) 
        {
            PRIBUR::IDevice* pDevice = m_pEnumerator->GetItem(i);
            if ( pDevice != NULL )
            {
                if ( ! boIsWritableOnly || pDevice->GetWritePossible() )
                {
                    CUnicode strDesc;
                    LPWSTR P = strDesc.GetBuffer(256);
                    memset(P, 0, 256 * sizeof(WCHAR));
                    pDevice->GetDescription(P, 256);
                    strDesc.ReleaseBuffer();
                    int iLetter = pDevice->GetDriveLetter();
                    m_vDeviceNames[i].Format(_T("%c:%s"), iLetter & 0xDF, CStr(strDesc));
                    TRACE2("%d %s\n", i, m_vDeviceNames[i]);
                    r++;
                }
                pDevice->Release();
            }
        }
        m_iDeviceNumber = r;
        return r;
    }
 
    int GetFoundDeviceNumber(void) const
    {
        return m_iDeviceNumber;
    }
 
    CStr GetFoundDeviceName(int iIndex) const
    {
        int c = 0;
        loop ( i, m_vDeviceNames.GetSize() )
        {
            const CStr& s = m_vDeviceNames[i];
            if ( ! s.IsEmpty() )
            {
                if ( c == iIndex )
                {
                    return s;
                }
                c++;
            }
        }
        return CStr();
    }
 
    CDevice CreateDevice(TCHAR tchLetter)
    {
        if ( m_pEnumerator == NULL )
        {
            Initialize();
        }
        loop ( i, m_vDeviceNames.GetSize() )
        {
            const CStr& s = m_vDeviceNames[i];
            if ( ! s.IsEmpty() && s[0] == (tchLetter & 0xDF) )
            {
                CDevice r(m_pEnumerator->GetItem(i));
                return r;
            }
        }
        return CDevice();
    }
 
private:
    bool m_InitEngine(void)
    {
        if ( m_pEngine == NULL )
        {
            m_pEngine = hpCDE::CreateEngine();
            if ( ! m_pEngine->Initialize() && ! m_pEngine->Initialize(TRUE) )
            {
                return false;
            }
        }
        return true;
    }
    void m_CloseEnumerator(void)
    {
        if ( m_pEnumerator != NULL) 
        {
            m_pEnumerator->Release();
            m_pEnumerator = NULL;
        }
    }
    PRIBUR::IEngine*            m_pEngine;          
    PRIBUR::IDeviceCollection*  m_pEnumerator;      
    CStrVector                  m_vDeviceNames;     
    int                         m_iDeviceNumber;    
};
 
 
 
}; //TNB