TnbMciPlayer.h

[詳解]

#pragma once
#include "TnbStr.h"
#include <mmsystem.h>
#include <digitalv.h>
#pragma comment(lib, "winmm.lib")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CMciPlayer : public CCopyImpossible
{
public:
 
    CMciPlayer(void) : m_isPlayed(false), m_lastError(0), m_hParent(NULL), m_wDeviceId(0), m_hViewWnd(NULL), m_isPaused(false)
    {
    }
 
    ~CMciPlayer(void)
    {
        Close();
    }
 
    void SetParentWnd(HWND hWnd)
    {
        m_hParent = hWnd;
    }
 
    MCIDEVICEID GetDeviceId() const
    {
        return m_wDeviceId;
    }
 
    bool OpenMidi(LPCTSTR lpszFileName)
    {
        LPCTSTR lpszDeviceType = reinterpret_cast<LPCTSTR>(MCI_DEVTYPE_SEQUENCER);
        return Open(lpszFileName, lpszDeviceType, true);
    }
 
    bool OpenMp3(LPCTSTR lpszFileName)
    {
        LPCTSTR lpszDeviceType = _T("MPEGVideo");
        return Open(lpszFileName, lpszDeviceType, false);
    }
 
    bool OpenWave(LPCTSTR lpszFileName)
    {
        LPCTSTR lpszDeviceType = reinterpret_cast<LPCTSTR>(MCI_DEVTYPE_WAVEFORM_AUDIO);
        return Open(lpszFileName, lpszDeviceType, true);
    }
 
    bool OpenAvi(LPCTSTR lpszFileName, HWND hViewWnd)
    {
        LPCTSTR lpszDeviceType = _T("MPEGVideo");   // _T("avivideo");
        return Open(lpszFileName, lpszDeviceType, false, hViewWnd);
    }
 
    bool Close(void)
    {
        bool r = true;
        if ( m_wDeviceId != 0 )
        {
            r = m_Cmd(MCI_CLOSE);
            if ( r )
            {
                m_isPaused = false;
                m_isPlayed = false;
                m_wDeviceId = 0;
                m_hViewWnd = NULL;
            }
        }
        return r;
    }
 
    bool IsOpened(void) const
    {
        return GetDeviceId() != 0;
    }
 
    bool GetLength(DWORD& _ms) const
    {
        return m_GetStatus(_ms, MCI_STATUS_LENGTH);
    }
 
    DWORD GetMode(void) const
    {
        DWORD mode;
        if ( m_GetStatus(mode, MCI_STATUS_MODE) )
        {
            return mode;
        }
        return MCI_MODE_NOT_READY;
    }
 
    bool Play(void)
    {
        MCI_PLAY_PARMS mciPlay = { 0 };
        bool r = m_Cmd(MCI_PLAY, 0, mciPlay);
        if ( r )
        {
            m_isPlayed = true;
            m_isPaused = false;
        }
        return r;
    }
 
    bool Stop(void)
    {
        bool r = m_Cmd(MCI_STOP);
        if ( r )
        {
            m_isPlayed = false;
        }
        return r;
    }
    
    bool Pause(bool isPause = true)
    {
        bool r = true;
        if ( m_isPlayed )
        {
            r = m_Cmd(isPause ? MCI_PAUSE : MCI_PLAY);
            if ( r )
            {
                m_isPaused = isPause;
            }
        }
        return r;
    }
 
    bool IsPaused(void) const
    {
        if ( m_isPlayed && GetMode() == MCI_MODE_PAUSE )
        {
            return true;
        }
        return false;
    }
 
    bool Seek(DWORD pos = 0, bool isResume = true)
    {
        if ( pos == 0 )
        {
            return m_Cmd(MCI_SEEK, MCI_SEEK_TO_START);
        }
        MCI_SEEK_PARMS mciSeek = { 0 };
        mciSeek.dwTo = pos;
        bool r = m_Cmd(MCI_SEEK, MCI_TO, mciSeek);
        if ( r && isResume )
        {
            r = m_Cmd(MCI_PLAY);
        }
        return r;
    }
 
    bool SetVolume(DWORD vol)
    {
        MCI_DGV_SETAUDIO_PARMS parm = { 0 };
        parm.dwItem = MCI_DGV_SETAUDIO_VOLUME;
        parm.dwValue = vol;
        return m_Cmd(MCI_SETAUDIO, MCI_DGV_SETAUDIO_ITEM | MCI_DGV_SETAUDIO_VALUE, parm);
    }
 
    bool GetPlayingPosition(DWORD& _ms) const
    {
        return m_GetStatus(_ms, MCI_STATUS_POSITION);
    }
 
    bool SetViewRect(const RECT& rect)
    {
        MCI_DGV_PUT_PARMS parms = { 0 };
        parms.rc = rect;
        return m_Cmd(MCI_PUT, MCI_DGV_RECT | MCI_DGV_PUT_DESTINATION, parms);
    }
 
    bool GetSourceSize(SIZE& _size) const
    {
        MCI_ANIM_RECT_PARMS parms = { 0 };
        if ( m_Cmd(MCI_WHERE, MCI_ANIM_WHERE_SOURCE, parms) )
        {
            _size.cx = parms.rc.right - parms.rc.left;
            _size.cy = parms.rc.bottom - parms.rc.top;
            return true;
        }
        return false;
    }
 
    MCIERROR GetLastError(void) const
    {
        return m_lastError;
    }
 
    static CStr GetErrorString(MCIERROR e)
    {
        CStr s;
        if ( e != MMSYSERR_NOERROR )
        {
            ::mciGetErrorString(e, s.GetBuffer(1000), 1000);
            s.ReleaseBuffer();
        }
        return s;
    }
 
protected:
 
    bool Open(LPCTSTR lpszFileName, LPCTSTR lpszDeviceType, bool isDeviceTypeId, HWND hViewWnd = NULL)
    {
        Stop();
        if ( IsOpened() )
        {
            Close();
        }
        DWORD p1 = MCI_OPEN_TYPE | MCI_OPEN_ELEMENT | (isDeviceTypeId ? MCI_OPEN_TYPE_ID : 0);
        DWORD p2 = 0;
        if ( hViewWnd == NULL )
        {
            Zero(m_openParms);
            m_openParms.lpstrDeviceType = lpszDeviceType;
            m_openParms.lpstrElementName = lpszFileName;
            p2 = reinterpret_cast<DWORD>(&m_openParms);
        }
        else
        {
            Zero(m_animOpenParms);
            m_animOpenParms.hWndParent = hViewWnd;
            m_animOpenParms.dwStyle = WS_CHILD;
            m_animOpenParms.lpstrDeviceType = lpszDeviceType;
            m_animOpenParms.lpstrElementName = lpszFileName;
            p1 |= (MCI_ANIM_OPEN_PARENT | MCI_ANIM_OPEN_WS);
            p2 = reinterpret_cast<DWORD>(&m_animOpenParms);
        }
        bool r = m_Rst(::mciSendCommand(NULL, MCI_OPEN, p1, p2));
        if ( r )
        {
            m_hViewWnd = hViewWnd;
            if ( hViewWnd == NULL )
            {
                m_wDeviceId = m_openParms.wDeviceID;
            }
            else
            {
                m_wDeviceId = m_animOpenParms.wDeviceID;
            }
        }
        if ( r )
        {
            MCI_SET_PARMS mciSet = { 0 };
            mciSet.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
            r = m_Cmd(MCI_SET, MCI_SET_TIME_FORMAT, mciSet);
        }
        if ( r && m_hViewWnd != NULL )
        {
            RECT rc;
            ::GetClientRect(m_hViewWnd, &rc);
            MCI_DGV_PUT_PARMS parms = { 0 };
            parms.rc = rc;
            r = m_Cmd(MCI_PUT, MCI_DGV_RECT | MCI_DGV_PUT_DESTINATION, parms);
        }
        return r;
    }
 
    void SetLastError(MCIERROR e)
    {
        m_lastError = e;
    }
 
private:
    bool m_RstFx(MCIERROR r) const
    {
        m_lastError = r;
        return r == 0;
    }
    bool m_Rst(MCIERROR r) const
    {
        m_lastError = r;
        if ( r != 0 )
        {
            TRACE2("MCIERROR = %d[%s]\n", r, GetErrorString(r));
        }
        return r == 0;
    }
    template<typename TYP>
    bool m_Cmd(UINT msg, DWORD param, TYP& typ) const
    {
        if ( IsOpened() )
        {
            if ( m_hParent != NULL )
            {
                typ.dwCallback = reinterpret_cast<DWORD>(m_hParent);
                param |= MCI_NOTIFY;
            }
            return m_Rst(::mciSendCommand(GetDeviceId(), msg, param, reinterpret_cast<DWORD>(&typ)));
        }
        return m_RstFx(MCIERR_DEVICE_NOT_READY);
    }
    bool m_Cmd(UINT msg, DWORD param = 0) const
    {
        MCI_GENERIC_PARMS p = { 0 };
        return m_Cmd(msg, param, p);
    }
    bool m_GetStatus(DWORD& _status, DWORD item) const
    {
        MCI_STATUS_PARMS mciStatus = { 0 };
        mciStatus.dwItem = item;
        bool r = m_Cmd(MCI_STATUS, MCI_STATUS_ITEM, mciStatus);
        if ( r )
        {
            _status = mciStatus.dwReturn;
        }
        return r;
    }
    MCI_OPEN_PARMS          m_openParms;        
    MCI_ANIM_OPEN_PARMS     m_animOpenParms;    
    MCIDEVICEID             m_wDeviceId;        
    HWND                    m_hViewWnd;         
    HWND                    m_hParent;          
    bool                    m_isPlayed;         
    bool                    m_isPaused;         
    mutable MCIERROR        m_lastError;        
};
 
 
 
}; //TNB