sh_audio.cpp

rsa算法打的一个包

// SH_Audio.cpp: implementation of the SH_Audio class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SH_Audio.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#ifdef _DEBUG
#define SH_AUDIO_CHECK_ERROR(err) do{                                \
    char __info[128] = {'\0'};                              \
    if((err)){                                              \
       if(mciGetErrorString((err),__info,sizeof(__info)-1)){\
            wsprintf(__info,"MCI_ERROR:%s\n",__info);       \
            TRACE(__info);                                  \
       }else                                                \
            TRACE("MCI error:unknown\n");                   \
        return FALSE;                                       \
    }                                                       \
}while(0)
#else
#define SH_AUDIO_CHECK_ERROR(err) do{}while(0)
#endif 

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

SH_Audio::SH_Audio()
{

    m_mciDevice    = (DWORD)(-1);
    m_mciError     = 0;
    m_mciTo        = 0;
    m_mciFrom      = 0;
    m_mciLength    = 0;   
    m_mciState     = SH_AUDIO_FREE;
    m_mciTimerTick = 0;
/*
    m_hWnd         = ::CreateWindow("STATIC",
                                    "SH_Audio Window",
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    NULL,
                                    NULL,
                                    AfxGetInstanceHandle(),
                                    NULL);

*/
    m_hWnd          = NULL;
}

SH_Audio::~SH_Audio()
{
   if(m_mciState != SH_AUDIO_FREE)
   {
       Stop();
   }
}

//////////////////////////////////////////////////////////////////////////////
//mci function
BOOL  SH_Audio::Play(LPCTSTR lpszAudio)
{
    BOOL bRet = TRUE;
   	MCI_OPEN_PARMS mop;
	MCI_PLAY_PARMS mpp;
	
    m_mciTimerTick = 0;
    //Open
    mop.lpstrElementName=lpszAudio;
	mop.lpstrDeviceType=NULL;
	
    m_mciError = mciSendCommand(0,MCI_OPEN,MCI_DEVTYPE_WAVEFORM_AUDIO,(DWORD)(LPVOID)&mop);
	SH_AUDIO_CHECK_ERROR(m_mciError);
    
    //Play
    m_mciDevice = mop.wDeviceID;
	mpp.dwCallback=(DWORD)m_hWnd;	
	
    m_mciLength=GetInfo(MCI_STATUS_LENGTH);    
    
	m_mciTo = MCI_MAKE_HMS(MCI_HMS_HOUR(m_mciLength),MCI_HMS_MINUTE(m_mciLength),MCI_HMS_SECOND(m_mciLength));  
	mpp.dwFrom = 0;
	mpp.dwTo = m_mciTo;

	m_mciError = mciSendCommand(m_mciDevice,MCI_PLAY,MCI_TO|MCI_FROM,(DWORD)(LPVOID)& mpp);

    SH_AUDIO_CHECK_ERROR(m_mciError); 
    
    m_mciState = SH_AUDIO_PLAY;
    return bRet;
}
BOOL  SH_Audio::Pause()
{
    MCI_GENERIC_PARMS mgp;

    m_mciFrom = GetInfo(MCI_STATUS_POSITION );
    mgp.dwCallback = (DWORD)m_hWnd;
    
    m_mciError = mciSendCommand(m_mciDevice,MCI_PAUSE,0,(DWORD)(LPVOID)&mgp);
    SH_AUDIO_CHECK_ERROR(m_mciError);
    
    m_mciState = SH_AUDIO_PAUSE;

    return TRUE;
}
BOOL  SH_Audio::Resume()
{
    MCI_GENERIC_PARMS mgp;

    mgp.dwCallback = (DWORD)m_hWnd;
    m_mciError = mciSendCommand(m_mciDevice,MCI_RESUME,0,(DWORD)(LPVOID)&mgp);
    SH_AUDIO_CHECK_ERROR(m_mciError);

    m_mciState = SH_AUDIO_PLAY;
    return TRUE;
}
BOOL  SH_Audio::Stop()
{
    m_mciTimerTick = 0;
   	
    m_mciTo =MCI_MAKE_HMS(0,0,0);
	
    m_mciError = mciSendCommand(m_mciDevice,MCI_CLOSE,0,NULL);
    
    SH_AUDIO_CHECK_ERROR(m_mciError);
    m_mciState = SH_AUDIO_FREE;
    return TRUE;
}
DWORD SH_Audio::GetInfo(DWORD dwItem)
{
    MCI_STATUS_PARMS msp;

    msp.dwCallback=(DWORD)m_hWnd;
	msp.dwItem=dwItem;
	msp.dwReturn=0;
	mciSendCommand(m_mciDevice,MCI_STATUS,MCI_STATUS_ITEM,(DWORD)(LPVOID)&msp);
	
    return (DWORD)msp.dwReturn;
}

MCIDEVICEID SH_Audio::GetDevice() const
{
    return m_mciDevice;
}
MCIERROR    SH_Audio::GetError() const
{
    return m_mciError;
}

DWORD       SH_Audio::GetTo() const
{
    return m_mciTo;
}

DWORD       SH_Audio::GetFrom() const
{
    return m_mciFrom;
}

DWORD       SH_Audio::GetLength() const
{
    return m_mciLength;
}

DWORD       SH_Audio::GetState() const
{
    return m_mciState;
}

DWORD       SH_Audio::GetTimerTick() const
{
    return m_mciTimerTick;
}

HWND        SH_Audio::GetHwnd() const
{
    return m_hWnd;
}