VC6多媒体定时器（回调函数定时方式）控制类

// MultimediaTimer.h: interface for the CMultimediaTimer class.
// 2005.3.9

#if !defined(TY_MultimediaTimer)
#define TY_MultimediaTimer

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "Mmsystem.h"                     //媒体定时器
#pragma comment(lib,"winmm")

const UINT TIMER_ACCURACY = 1;           //定义时钟分辨率，以ms为单位
#define MTIMER_MAXLIMIT  0x0001
#define MTIMER_MINLIMIT  0x0002
#define MTIMER_NORMAL    0x0004
#define MCONTROL_NOSPEEDUP    MTIMER_MINLIMIT
#define MCONTROL_NOSLOWDOWN  MTIMER_MAXLIMIT
#define MCONTROL_NOLIMIT     MTIMER_NORMAL

class CMultimediaTimer
{ 
public:
 CMultimediaTimer();
 virtual ~CMultimediaTimer();

public://播放控制函数
 void Start(UINT timerCurRes, BOOL bOneShot);    //启动定时器
 void Start(BOOL bOneShot = FALSE);      
 void Stop();         //停止定时器
 void Pause();                                   //暂停定时器
 BOOL SpeedUp();            //加快播放速度
 BOOL SlowDown();        //减慢播放速度
 void SetRange(UINT Lower, UINT Upper);          //设置定时时间调节范围，对带参的Start和SetCurRes函数无效
 void GetRange(UINT &Lower, UINT &Upper) const;  //获得定时时间范围
 void SetCurRes(UINT timerCurRes);               //获得当前时间间隔
 void SetProcParameter(LPTIMECALLBACK callbackproc, DWORD dwUser);           
                                                 //设置回调函数和传入参数
 BOOL IsStart() const;                           //定时器是否运行
 BOOL IsStop() const;          //定时器是否终止
 BOOL IsPause() const;       //定时器是否暂停
 UINT GetResState();           //获得定时器时间间隔状态
 UINT GetCurRes() const;             //获得当前时间间隔
 const TIMECAPS& timeGetDevCaps() const;         //获得定时器分辨率范围
protected:
 virtual void OnSpeedUp(UINT &timerCurRes);      //当速度提高的时候被调用
 virtual void OnSlowDown(UINT &timerCurRes);     //当速度降低的时候被调用
 UINT GetResState(UINT Res) const;               //返回Res的状态
private:
 TIMECAPS m_tc;                                  
 UINT  m_CurTimerRes;                         //当前时间间隔
 BOOL  m_bTimerStop;                          //定时器是否已经启动
 BOOL     m_bTimerPause;                         //定时器是否暂停
 DWORD  m_dwUser;                              //回调函数的传入参数
 UINT  m_wAccuracy;                           //使用的分辨率
 UINT  m_TimerID;                             //定义定时器句柄
 LPTIMECALLBACK m_pCallBackProc;                 //回调函数指针

 UINT m_MaxTimeSpace;                            //最大定时器间隔
 UINT m_MinTimeSpace;                            //最小定时器间隔
};

#endif // !defined(TY_MultimediaTimer)

// MultimediaTimer.cpp: implementation of the CMultimediaTimer class.
//
//

#include "stdafx.h"
#include "MultimediaTimer.h"

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

//
// Construction/Destruction
//

CMultimediaTimer::CMultimediaTimer()
{
 m_MaxTimeSpace  = 2560;      //最大定时器间隔为 2560 ms [2^X]         
 m_MinTimeSpace  = 10  ;      //最小定时器间隔为 10 ms  [原速]
 //
 m_CurTimerRes   = 10;        //初始多媒体定时间隔10ms
 m_bTimerStop    = TRUE;
 m_bTimerPause   = TRUE;
 m_pCallBackProc = NULL;

 if(::timeGetDevCaps(&m_tc,sizeof(TIMECAPS)) == TIMERR_NOERROR)  
 {
  m_wAccuracy = min(max(m_tc.wPeriodMin,TIMER_ACCURACY),m_tc.wPeriodMax);
  timeBeginPeriod(m_wAccuracy);
 } 
}

CMultimediaTimer::~CMultimediaTimer()
{
 timeKillEvent(m_TimerID);
 timeEndPeriod(m_wAccuracy);
}

//启动定时器
void CMultimediaTimer::Start(BOOL bOneShot /*= FALSE/**/)
{
 ASSERT(m_pCallBackProc != NULL);
 UINT fuEvent = (bOneShot ? TIME_ONESHOT : TIME_PERIODIC);
 if(m_bTimerStop || m_bTimerPause)
 {
  m_TimerID = timeSetEvent(m_CurTimerRes,
                        m_wAccuracy,
         (LPTIMECALLBACK) m_pCallBackProc,
         m_dwUser,
         fuEvent);
  m_bTimerStop  = FALSE;
  m_bTimerPause = FALSE;
 }
}

void CMultimediaTimer::Start(UINT timerCurRes, BOOL bOneShot)
{
 ASSERT(m_pCallBackProc != NULL);
 m_CurTimerRes = max(min(timerCurRes,m_tc.wPeriodMax),m_wAccuracy);
 UINT fuEvent  = (bOneShot ? TIME_ONESHOT : TIME_PERIODIC);
 if(m_bTimerStop || m_bTimerPause)
 {
  m_TimerID = timeSetEvent(m_CurTimerRes,
   m_wAccuracy,
   m_pCallBackProc,
   m_dwUser,
   fuEvent);
  m_bTimerStop  = FALSE;
  m_bTimerPause = FALSE;
 }
}

//停止定时器
void CMultimediaTimer::Stop()
{
 timeKillEvent(m_TimerID);
 m_bTimerStop  = TRUE;
 m_bTimerPause = FALSE;
}

//暂停定时器
void CMultimediaTimer::Pause()
{
 timeKillEvent(m_TimerID);
 if(!m_bTimerStop && !m_bTimerPause)
 {
  m_bTimerPause = TRUE;
 }
}

//加快播放速度，减少定时间隔
BOOL CMultimediaTimer::SpeedUp()
{
 switch(GetResState())
 {
 case MTIMER_MAXLIMIT:
  m_CurTimerRes = m_MaxTimeSpace;
  break;
 case MTIMER_MINLIMIT:
  m_CurTimerRes = m_MinTimeSpace;
  break;
 default:;
 }
 UINT nOldRes = m_CurTimerRes;
 OnSpeedUp(nOldRes);
 if(GetResState(nOldRes) == MTIMER_NORMAL)
  m_CurTimerRes = nOldRes;
 else return FALSE;
 
 if(!m_bTimerStop && !m_bTimerPause)
 {
  timeKillEvent(m_TimerID);
  m_TimerID = timeSetEvent(m_CurTimerRes,
   m_wAccuracy,
   m_pCallBackProc,
   m_dwUser,
   TIME_PERIODIC);
 }
 return TRUE;
}

//减慢播放速度，增加定时间隔
BOOL CMultimediaTimer::SlowDown()
{ 
 switch(GetResState())
 {
 case MTIMER_MAXLIMIT:
  m_CurTimerRes = m_MaxTimeSpace;
  break;
 case MTIMER_MINLIMIT:
  m_CurTimerRes = m_MinTimeSpace;
  break;
 default:;
 }
 UINT nOldRes = m_CurTimerRes;
 OnSlowDown(nOldRes);
 if(GetResState(nOldRes) == MTIMER_NORMAL)
  m_CurTimerRes = nOldRes;
 else return FALSE;
 
 if(!m_bTimerStop && !m_bTimerPause)
 {
  timeKillEvent(m_TimerID);
  m_TimerID = timeSetEvent(m_CurTimerRes,
   m_wAccuracy,
   m_pCallBackProc,
   m_dwUser,
   TIME_PERIODIC);
 }
 return TRUE;
}

//设置定时时间调节范围，对带参的Start和SetCurRes函数无效
void CMultimediaTimer::SetRange(UINT Lower, UINT Upper)
{
 //Make change
 if(Lower > Upper)
 {
  UINT temp = Lower;
  Lower = Upper;
  Upper = temp;
 }
 m_MinTimeSpace = max(min(Lower,m_tc.wPeriodMax),m_wAccuracy);
 m_MaxTimeSpace = max(min(m_tc.wPeriodMax,Upper),m_MinTimeSpace);
}

//获得定时时间范围
void CMultimediaTimer::GetRange(UINT &Lower, UINT &Upper) const
{
 Lower = m_MinTimeSpace;
 Upper = m_MaxTimeSpace;
}

//获得当前时间间隔
void CMultimediaTimer::SetCurRes(UINT timerCurRes)
{
 m_CurTimerRes = max(min(timerCurRes,m_tc.wPeriodMax),m_wAccuracy);
}

//设置回调函数和传入参数
void CMultimediaTimer::SetProcParameter(LPTIMECALLBACK callbackproc, DWORD dwUser)
{
 m_pCallBackProc = callbackproc;
 m_dwUser = dwUser;
}

//定时器是否运行
BOOL CMultimediaTimer::IsStart() const
{
 return (!m_bTimerPause && !m_bTimerStop);
}

//定时器是否已经启动
BOOL CMultimediaTimer::IsStop() const
{
 return m_bTimerStop;
}

//获得定时器暂停状态
BOOL CMultimediaTimer::IsPause() const
{
 return m_bTimerPause;
}

//返回Res的状态
UINT CMultimediaTimer::GetResState(UINT Res) const
{
 if(Res < m_MinTimeSpace)
  return MTIMER_MINLIMIT;
 if(Res > m_MaxTimeSpace)
  return  MTIMER_MAXLIMIT;
 return MTIMER_NORMAL;
}

//获得定时器状态
UINT CMultimediaTimer::GetResState()
{
 UINT temp,r1,r2;
 temp = m_CurTimerRes;
 OnSpeedUp(temp); 
 r1 = GetResState(temp);
 temp = m_CurTimerRes;
 OnSlowDown(temp);
 r2 = GetResState(temp);
 if(r1 == MTIMER_MINLIMIT && r2 == MTIMER_MAXLIMIT)
  return MTIMER_MINLIMIT|MTIMER_MAXLIMIT;
 if(r1 == MTIMER_MINLIMIT)
  return MTIMER_MINLIMIT;
 if(r2 == MTIMER_MAXLIMIT)
  return MTIMER_MAXLIMIT;
 return MTIMER_NORMAL;
}

//获得当前时间间隔
UINT CMultimediaTimer::GetCurRes() const
{
 return m_CurTimerRes;
}

//获得定时器分辨率范围
const TIMECAPS& CMultimediaTimer::timeGetDevCaps() const
{
 return m_tc;
}

//当速度提高的时候被调用
void CMultimediaTimer::OnSpeedUp(UINT &timerCurRes)
{//SpeedUp algorithm
 timerCurRes = timerCurRes / 2;
}

//当速度降低的时候被调用
void CMultimediaTimer::OnSlowDown(UINT &timerCurRes)
{//SlowDown algorithm
 timerCurRes = timerCurRes * 2;
}