repos_ecs/Device/HC_CARDOCX/StoneU_HC_CARDOCX/PlayerDlg.cpp

////////////////////////////////////////////////////////////////////////////////
//File:PlayerDlg.cpp 
/////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "StoneU_HC_CARDOCX.h"
#include "PlayerDlg.h"
#include "vkey.h"
#include "info.h"
#include "cutfile.h"
#include "HelpDlg.h"
#include "CConvertAVI.h"
#include "Extern.h"
#include ".\playerdlg.h"
#include "Global.h"

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


// class used to convert file to avi
CConvertAVI g_classAVI;

CPlayerDlg::CPlayerDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CPlayerDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CPlayerDlg)
	m_strPlayStateText       = _T("");
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon	                  =	AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	// Init the parameters
	m_bInit = false;
}

void CPlayerDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CPlayerDlg)
	DDX_Control(pDX, IDC_PLAYSTATETEXT, m_ctrlPlayText);
	DDX_Control(pDX, IDC_CAPPIC, m_ctrlBtnCapPic);
	DDX_Control(pDX, IDC_SOUND, m_ctrlBtnSound);
	DDX_Control(pDX, IDC_STEPBACK, m_ctrlStepBackward);
	DDX_Control(pDX, IDC_STEP, m_ctrlStepForward);
	DDX_Control(pDX, IDC_SLOW, m_ctrlBtnSlow);
	DDX_Control(pDX, IDC_FAST, m_ctrlBtnFast);
	DDX_Control(pDX, IDC_GOTOSTART, m_ctrlBtnGStart);
	DDX_Control(pDX, IDC_GOTOEND, m_ctrlBtnGEnd);
	DDX_Control(pDX, IDC_STOP, m_ctrlBtnStop);
	DDX_Control(pDX, IDC_PLAY, m_ctrlBtnPlay);
	DDX_Control(pDX, IDC_PAUSE, m_ctrlBtnPause);
	DDX_Control(pDX, IDC_SHOW, m_ctrlVideoPic);
	DDX_Text(pDX, IDC_PLAYSTATETEXT, m_strPlayStateText);
	DDX_Control(pDX, IDC_SOUND_SLIDER, m_SoundSlider);
	//}}AFX_DATA_MAP
	DDX_Control(pDX, IDC_LIST_VEDIO, m_List_Vedio);
	DDX_Control(pDX, IDC_DATETIME_BEGIN, m_timeBegin);
	DDX_Control(pDX, IDC_DATETIME_END, m_timeEnd);
	DDX_Control(pDX, IDC_BTN_QUERY, m_btnQuery);
}

BEGIN_MESSAGE_MAP(CPlayerDlg, CDialog)
	//{{AFX_MSG_MAP(CPlayerDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_WM_KEYDOWN()
	ON_WM_HSCROLL()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_CLOSE()
	ON_WM_TIMER()
	ON_WM_SIZE()
	ON_WM_DROPFILES()
	ON_WM_MOVE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_DESTROY()
	ON_WM_WINDOWPOSCHANGED()
	ON_WM_GETMINMAXINFO()
	//}}AFX_MSG_MAP
	ON_COMMAND_RANGE(IDM_VIEW_FULLSCREEN, IDM_DEVICE3, OnMenuItem)
	ON_COMMAND_RANGE(IDC_PLAY, IDC_SOUND, OnButtonItem)
//	ON_MESSAGE(WM_FILE_END, PlayMessage)
//	ON_MESSAGE(WM_ENC_CHANGE,EncChangeMessage)
//	ON_MESSAGE(WM_SEEKOK, SeekOk)
//	ON_MESSAGE(WM_DISPLAY_OK, DisplayOk)
//	ON_MESSAGE(WM_VIDEOCTRL_OK, VideoCtrlOK)

ON_BN_CLICKED(IDC_BTN_QUERY, OnBnClickedBtnQuery)
ON_NOTIFY(NM_DBLCLK, IDC_LIST_VEDIO, OnNMDblclkListVedio)
ON_WM_CTLCOLOR()
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPlayerDlg message handlers

BOOL CPlayerDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	//SetCtrlPos();

	// Add "About..." menu item to system menu.

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// TODO: Add extra initialization here
	m_pMainMenu = GetMenu();
	if(m_pMainMenu == NULL)
	{
		TRACE("GetMenu is Error!");
		return FALSE;
	}

	SetCtrlPos( CRect(0,0,g_nFrameWeight-15,g_nFrameHeight-100) );

	InitList( &m_List_Vedio );
	Init();

	CTime tmEnd; 
	tmEnd=CTime::GetCurrentTime(); 
	m_timeEnd.SetTime(&tmEnd); 
	m_timeEnd.SetFormat(_T("yyyy-M-d HH:mm:ss")); 

	time_t timeTemp=tmEnd.GetTime(); 
	COleDateTime timeEnd(timeTemp);
	COleDateTime timeBegin = timeEnd-COleDateTimeSpan( 2,0,0,0 );

	SYSTEMTIME systime;
	VariantTimeToSystemTime(timeBegin, &systime);
	CTime tmBegin(systime);
	m_timeBegin.SetTime(&tmBegin); 
	m_timeBegin.SetFormat(_T("yyyy-M-d HH:mm:ss")); 

	CTime tmB(tmBegin.GetYear(),tmBegin.GetMonth(),tmBegin.GetDay(),0,0,0);
	m_timeBegin.SetTime( &tmB );

	CTime tmE(tmEnd.GetYear(),tmEnd.GetMonth(),tmEnd.GetDay(),23,59,59);
	m_timeEnd.SetTime( &tmE );

	//m_btnQuery.SetBitmaps(IDB_BITMAP_QUERY, RGB(255, 0, 255));
	//m_btnQuery.SetFlat(FALSE);
	//m_btnQuery.SetAlign(CButtonST::ST_ALIGN_HORIZ);
	//m_btnQuery.SetIcon(IDI_QUERY);
	//m_btnQuery.SetFlat(FALSE);
	//m_btnQuery.SetAlign(CButtonST::ST_ALIGN_HORIZ);
		//SetVideoCtrlPos();
	return TRUE;  // return TRUE  unless you set the focus to a control
}
void CPlayerDlg::SetCtrlPos( CRect rect )
{
	this->MoveWindow( rect );

	CRect rMain;
	this->GetWindowRect( rMain );
	ScreenToClient( &rMain );

	int W=0,H=0;
	
	//操作
	CRect rcSta1;
	GetDlgItem(IDC_STATIC_1)->GetWindowRect( rcSta1 );
	W = rcSta1.Width();
	H = rcSta1.Height();
	rcSta1.right = rMain.right-5;
	rcSta1.left = rcSta1.right-W;
	rcSta1.bottom = rMain.bottom-5;
	rcSta1.top = rcSta1.bottom-H;
	GetDlgItem(IDC_STATIC_1)->MoveWindow(rcSta1);

	CRect rcBtnQuery;
	GetDlgItem(IDC_BTN_QUERY)->GetWindowRect( rcBtnQuery );
	W = rcBtnQuery.Width();
	H = rcBtnQuery.Height();
	rcBtnQuery.left = rcSta1.left+10;
	rcBtnQuery.right = rcSta1.right-10;
	rcBtnQuery.bottom = rcSta1.bottom-5;
	rcBtnQuery.top = rcBtnQuery.bottom-H;
	GetDlgItem(IDC_BTN_QUERY)->MoveWindow(rcBtnQuery);

	CRect rcDateE;
	GetDlgItem(IDC_DATETIME_END)->GetWindowRect( rcDateE );
	W = rcDateE.Width();
	H = rcDateE.Height();
	rcDateE.left = rcSta1.left+10;
	rcDateE.right = rcSta1.right-10;
	rcDateE.bottom = rcBtnQuery.top-5;
	rcDateE.top = rcDateE.bottom-H;
	GetDlgItem(IDC_DATETIME_END)->MoveWindow(rcDateE);

	CRect rcDateS;
	GetDlgItem(IDC_DATETIME_BEGIN)->GetWindowRect( rcDateS );
	W = rcDateS.Width();
	H = rcDateS.Height();
	rcDateS.left = rcSta1.left+10;
	rcDateS.right = rcSta1.right-10;
	rcDateS.bottom = rcDateE.top-5;
	rcDateS.top = rcDateS.bottom-H;
	GetDlgItem(IDC_DATETIME_BEGIN)->MoveWindow(rcDateS);

	//列表
	CRect rcList;
	GetDlgItem(IDC_LIST_VEDIO)->GetWindowRect( rcList );
	W = rcList.Width();
	H = rcList.Height();
	rcList.right = rMain.right-5;
	rcList.left = rcSta1.right-W;
	rcList.top = 0;
	rcList.bottom = rcSta1.top-0;
	GetDlgItem(IDC_LIST_VEDIO)->MoveWindow(rcList);

	
	CRect rcStaVedioBtn;
	GetDlgItem(IDC_STATIC_VEDIOBTN)->GetWindowRect( rcStaVedioBtn );//ScreenToClient( rcStaVedioBtn );
	W = rcStaVedioBtn.Width();
	H = rcStaVedioBtn.Height();
	rcStaVedioBtn.left = ( rMain.Width()-rcSta1.Width())/2-W/2;
	rcStaVedioBtn.right = rcStaVedioBtn.left+W;
	rcStaVedioBtn.bottom = rMain.bottom-5;
	rcStaVedioBtn.top = rcStaVedioBtn.bottom-H;
	GetDlgItem(IDC_STATIC_VEDIOBTN)->MoveWindow(rcStaVedioBtn);

	CRect rcSlider;
	GetDlgItem(IDC_PLAY_RECT_SLIDER)->GetWindowRect( rcSlider );
	W = rcSlider.Width();
	H = rcSlider.Height();
	rcSlider.left = rcStaVedioBtn.left;
	rcSlider.right = rcStaVedioBtn.right;
	rcSlider.top = rcStaVedioBtn.top;
	rcSlider.bottom = rcSlider.top+H;
	GetDlgItem(IDC_PLAY_RECT_SLIDER)->MoveWindow(rcSlider);

	CRect rcText;
	GetDlgItem(IDC_PLAYSTATETEXT)->GetWindowRect( rcText );
	W = rcText.Width();
	H = rcText.Height();
	rcText.left = rcStaVedioBtn.left;
	rcText.right = rcStaVedioBtn.right;
	rcText.bottom = rcStaVedioBtn.bottom;
	rcText.top = rcText.bottom-H;
	GetDlgItem(IDC_PLAYSTATETEXT)->MoveWindow(rcText);

	CRect rcBtnPlay;
	GetDlgItem(IDC_PLAY)->GetWindowRect( rcBtnPlay );
	W = rcBtnPlay.Width();
	H = rcBtnPlay.Height();
	rcBtnPlay.left = rcText.left+3;
	rcBtnPlay.right = rcBtnPlay.left+W;
	rcBtnPlay.bottom = rcText.top-11;
	rcBtnPlay.top = rcBtnPlay.bottom-H;
	GetDlgItem(IDC_PLAY)->MoveWindow(rcBtnPlay);

	CRect rcBtnPause;
	GetDlgItem(IDC_PAUSE)->GetWindowRect( rcBtnPause );
	W = rcBtnPause.Width();
	H = rcBtnPause.Height();
	rcBtnPause.left = rcBtnPlay.right+7;
	rcBtnPause.right = rcBtnPause.left+W;
	rcBtnPause.bottom = rcText.top-11;
	rcBtnPause.top = rcBtnPlay.bottom-H;
	GetDlgItem(IDC_PAUSE)->MoveWindow(rcBtnPause);

	CRect rcBtnStop;
	GetDlgItem(IDC_STOP)->GetWindowRect( rcBtnStop );
	W = rcBtnStop.Width();
	H = rcBtnStop.Height();
	rcBtnStop.left = rcBtnPause.right+7;
	rcBtnStop.right = rcBtnStop.left+W;
	rcBtnStop.bottom = rcText.top-11;
	rcBtnStop.top = rcBtnStop.bottom-H;
	GetDlgItem(IDC_STOP)->MoveWindow(rcBtnStop);

	CRect rcInter1;
	GetDlgItem(IDC_INTER1)->GetWindowRect( rcInter1 );
	W = rcInter1.Width();
	H = rcInter1.Height();
	rcInter1.left = rcBtnStop.right+5;
	rcInter1.right = rcInter1.left+W;
	rcInter1.bottom = rcText.top-5;
	rcInter1.top = rcInter1.bottom-H;
	GetDlgItem(IDC_INTER1)->MoveWindow(rcInter1);

	CRect rcBtnGoToStart;
	GetDlgItem(IDC_GOTOSTART)->GetWindowRect( rcBtnGoToStart );
	W = rcBtnGoToStart.Width();
	H = rcBtnGoToStart.Height();
	rcBtnGoToStart.left = rcInter1.right+7;
	rcBtnGoToStart.right = rcBtnGoToStart.left+W;
	rcBtnGoToStart.bottom = rcText.top-10;
	rcBtnGoToStart.top = rcBtnGoToStart.bottom-H;
	GetDlgItem(IDC_GOTOSTART)->MoveWindow(rcBtnGoToStart);

	CRect rcBtnSlow;
	GetDlgItem(IDC_SLOW)->GetWindowRect( rcBtnSlow );
	W = rcBtnSlow.Width();
	H = rcBtnSlow.Height();
	rcBtnSlow.left = rcBtnGoToStart.right+1;
	rcBtnSlow.right = rcBtnSlow.left+W;
	rcBtnSlow.bottom = rcText.top-10;
	rcBtnSlow.top = rcBtnSlow.bottom-H;
	GetDlgItem(IDC_SLOW)->MoveWindow(rcBtnSlow);

	CRect rcBtnFast;
	GetDlgItem(IDC_FAST)->GetWindowRect( rcBtnFast );
	W = rcBtnFast.Width();
	H = rcBtnFast.Height();
	rcBtnFast.left = rcBtnSlow.right+1;
	rcBtnFast.right = rcBtnFast.left+W;
	rcBtnFast.bottom = rcText.top-10;
	rcBtnFast.top = rcBtnFast.bottom-H;
	GetDlgItem(IDC_FAST)->MoveWindow(rcBtnFast);

	CRect rcBtnGoToEnd;
	GetDlgItem(IDC_GOTOEND)->GetWindowRect( rcBtnGoToEnd );
	W = rcBtnGoToEnd.Width();
	H = rcBtnGoToEnd.Height();
	rcBtnGoToEnd.left = rcBtnFast.right+1;
	rcBtnGoToEnd.right = rcBtnGoToEnd.left+W;
	rcBtnGoToEnd.bottom = rcText.top-10;
	rcBtnGoToEnd.top = rcBtnGoToEnd.bottom-H;
	GetDlgItem(IDC_GOTOEND)->MoveWindow(rcBtnGoToEnd);

	CRect rcInter2;
	GetDlgItem(IDC_INTER2)->GetWindowRect( rcInter2 );
	W = rcInter2.Width();
	H = rcInter2.Height();
	rcInter2.left = rcBtnGoToEnd.right+5;
	rcInter2.right = rcInter2.left+W;
	rcInter2.bottom = rcText.top-5;
	rcInter2.top = rcInter2.bottom-H;
	GetDlgItem(IDC_INTER2)->MoveWindow(rcInter2);

	CRect rcBtnStepBack;
	GetDlgItem(IDC_STEPBACK)->GetWindowRect( rcBtnStepBack );
	W = rcBtnStepBack.Width();
	H = rcBtnStepBack.Height();
	rcBtnStepBack.left = rcInter2.right+1;
	rcBtnStepBack.right = rcBtnStepBack.left+W;
	rcBtnStepBack.bottom = rcText.top-10;
	rcBtnStepBack.top = rcBtnStepBack.bottom-H;
	GetDlgItem(IDC_STEPBACK)->MoveWindow(rcBtnStepBack);

	CRect rcBtnStep;
	GetDlgItem(IDC_STEP)->GetWindowRect( rcBtnStep );
	W = rcBtnStep.Width();
	H = rcBtnStep.Height();
	rcBtnStep.left = rcBtnStepBack.right+1;
	rcBtnStep.right = rcBtnStep.left+W;
	rcBtnStep.bottom = rcText.top-10;
	rcBtnStep.top = rcBtnStep.bottom-H;
	GetDlgItem(IDC_STEP)->MoveWindow(rcBtnStep);

	CRect rcInter3;
	GetDlgItem(IDC_INTER3)->GetWindowRect( rcInter3 );
	W = rcInter3.Width();
	H = rcInter3.Height();
	rcInter3.left = rcBtnStep.right+5;
	rcInter3.right = rcInter3.left+W;
	rcInter3.bottom = rcText.top-5;
	rcInter3.top = rcInter3.bottom-H;
	GetDlgItem(IDC_INTER3)->MoveWindow(rcInter3);

	CRect rcBtnCapPic;
	GetDlgItem(IDC_CAPPIC)->GetWindowRect( rcBtnCapPic );
	W = rcBtnCapPic.Width();
	H = rcBtnCapPic.Height();
	rcBtnCapPic.left = rcInter3.right+6;
	rcBtnCapPic.right = rcBtnCapPic.left+W;
	rcBtnCapPic.bottom = rcText.top-10;
	rcBtnCapPic.top = rcBtnCapPic.bottom-H;
	GetDlgItem(IDC_CAPPIC)->MoveWindow(rcBtnCapPic);

	CRect rcBtnSound;
	GetDlgItem(IDC_SOUND)->GetWindowRect( rcBtnSound );
	W = rcBtnSound.Width();
	H = rcBtnSound.Height();
	rcBtnSound.left = rcBtnCapPic.right+6;
	rcBtnSound.right = rcBtnSound.left+W;
	rcBtnSound.bottom = rcText.top-10;
	rcBtnSound.top = rcBtnSound.bottom-H;
	GetDlgItem(IDC_SOUND)->MoveWindow(rcBtnSound);

	CRect rcSliderSound;
	GetDlgItem(IDC_SOUND_SLIDER)->GetWindowRect( rcSliderSound );
	W = rcSliderSound.Width();
	H = rcSliderSound.Height();
	rcSliderSound.left = rcBtnSound.right+6;
	rcSliderSound.right = rcSliderSound.left+W;
	rcSliderSound.bottom = rcText.top-10;
	rcSliderSound.top = rcSliderSound.bottom-H;
	GetDlgItem(IDC_SOUND_SLIDER)->MoveWindow(rcSliderSound);
	//Video 
	CRect rcVideo;
	GetDlgItem(IDC_SHOW)->GetWindowRect( rcVideo );
	rcVideo.left = 0;
	rcVideo.top = 0;
	rcVideo.right = rcList.left-5;
	rcVideo.bottom = rcList.bottom;
	GetDlgItem(IDC_SHOW)->MoveWindow(rcVideo);
}
void CPlayerDlg::SetVideoCtrlPos( ) 
{
	//m_ctrlBtnPlay.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnPause.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnStop.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnFast.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnGEnd.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnSlow.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnGStart.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlStepForward.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlStepBackward.ModifyStyle(0, WS_VISIBLE, 0);
	//m_ctrlBtnCapPic.ModifyStyle(0, WS_VISIBLE, 0);			
	//m_ctrlBtnSound.ModifyStyle(0, WS_VISIBLE, 0);

	//GetDlgItem(IDC_INTER1)->ModifyStyle(0, WS_VISIBLE, 0);
	//GetDlgItem(IDC_INTER2)->ModifyStyle(0, WS_VISIBLE, 0);
	//GetDlgItem(IDC_INTER3)->ModifyStyle(0, WS_VISIBLE, 0);

	//m_PlaySlider.ModifyStyle(0,WS_VISIBLE,0);
	//m_SoundSlider.ModifyStyle(0,WS_VISIBLE,0);

	//m_ctrlPlayText.ModifyStyle(0,WS_VISIBLE,0);
	
	//make the window can be resize.
	//ModifyStyle(0, WS_SIZEBOX, 0);
	//change the window pos to pre rect.
	//SetWindowPlacement(&m_OldWndpl);
	//列表
	CRect rcList2;
	GetDlgItem(IDC_LIST_VEDIO)->GetWindowRect( rcList2 );
	//Video 
	CRect rcVideo1,rcVideo2;
	GetDlgItem(IDC_SHOW)->GetWindowRect( rcVideo1 );
	rcVideo2.left = 0;
	rcVideo2.top = 0;
	rcVideo2.right = rcList2.left-2;
	rcVideo2.bottom = rcList2.bottom;
	GetDlgItem(IDC_SHOW)->MoveWindow(rcVideo2,true);

	//this->RedrawWindow();
}
HBRUSH CPlayerDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);

	// TODO:  在此更改 DC 的任何属性
	int   nID   =   pWnd->GetDlgCtrlID();   

	//HBRUSH B1 = CreateSolidBrush( RGB(236,233,216) );  
	if( nID == IDC_STA_MESSAGE)
    {   
		pDC->SetTextColor(RGB( 255,0,0));   
		pDC->SetBkMode( TRANSPARENT );

		//return B1; 
    } 
	//DeleteObject(B1);
	// TODO:  如果默认的不是所需画笔，则返回另一个画笔
	return hbr;
}

void CPlayerDlg::InitList( CListCtrlCl *pListCtrlCl )
{
	//pListCtrlCl->SetColColor(0,RGB(10,150,20)); //设置列背景色
	//pListCtrlCl->SetColColor(2,RGB(30,100,90)); //设置列背景色
	//pListCtrlCl->SetBkColor(RGB(50,10,10));        //设置背景色
	//pListCtrlCl->SetItemColor(1,1,RGB(100,100,10)); //设置指定单元背景色
	//pListCtrlCl->SetRowHeigt(25);               //设置行高度
	//pListCtrlCl->SetHeaderHeight(1.5);          //设置头部高度
	//pListCtrlCl->SetHeaderFontHW(16,0);         //设置头部字体高度,和宽度,0表示缺省，自适应 
	pListCtrlCl->SetHeaderTextColor(RGB(0,0,0)); //设置头部字体颜色
	//pListCtrlCl->SetTextColor(RGB(0,255,255));  //设置文本颜色
	pListCtrlCl->SetHeaderBKColor(213,222,242,8); //设置头部背景色
	////pListCtrlCl->SetFontHW(15,0);               //设置字体高度，和宽度,0表示缺省宽度
	//pListCtrlCl->SetColTextColor(2,RGB(255,255,100)); //设置列文本颜色
	//pListCtrlCl->SetItemTextColor(3,1,RGB(255,0,0));  //设置单元格字体颜色

	pListCtrlCl->InsertColumn(0,_T("視頻列表（双击打开）"),LVCFMT_LEFT,190);
	//pListCtrlCl->InsertColumn(1,_T("和"),LVCFMT_CENTER,29);

	pListCtrlCl->SetTextBkColor( RGB(213,222,242) );
	pListCtrlCl->SetBkColor( RGB(213,222,242) );

	SetWindowLong(pListCtrlCl->m_hWnd ,GWL_EXSTYLE,WS_EX_CLIENTEDGE);
	pListCtrlCl->SetExtendedStyle(LVS_EX_GRIDLINES);                     //设置扩展风格为网格
	::SendMessage(pListCtrlCl->m_hWnd, LVM_SETEXTENDEDLISTVIEWSTYLE,
		LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
}
void CPlayerDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	//if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	//{
	//	CAboutDlg dlgAbout;
	//	dlgAbout.DoModal();
	//}
	//else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CPlayerDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

	//	SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
	this->UpdateWindow();
	NAME(PlayM4_RefreshPlay)(PORT);
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CPlayerDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

//////////////////////////////////////////////////////////////////////////////
//Function: called when u drag a file to the playing window
//////////////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnDropFiles(HDROP hDropInfo) 
{
	// TODO: Add your message handler code here and/or call default
	
	DWORD nFileNameSize = DragQueryFile(hDropInfo, 0, NULL, 0);
	char * sFileName	= new char[nFileNameSize + 1];
	DragQueryFile(hDropInfo, 0, sFileName, nFileNameSize + 1);
	m_strPlayFileName   = sFileName;
	
	Open();
	SetState();

	delete []sFileName;
	CDialog::OnDropFiles(hDropInfo);
}


//////////////////////////////////////////////////////////////////////////////
//Function: overload to handle keydown message
//////////////////////////////////////////////////////////////////////////////
BOOL CPlayerDlg::PreTranslateMessage(MSG* lpmsg)
{
	
	switch (lpmsg->message)
	{
		case WM_KEYDOWN:
			OnKeyDown(lpmsg->wParam, LOWORD(lpmsg ->lParam), HIWORD(lpmsg->lParam));
			return TRUE;
			
		default:
			break;
	} 

	return CDialog::PreTranslateMessage(lpmsg); 
}


//////////////////////////////////////////////////////////////////////////////
//Function: hot key
//////////////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	// TODO: Add your message handler code here and/or call default
	UINT  nMenuState;
//
	//if(nChar == VK_F2) 
		//ViewFullScreen();


	if(GetKeyState(VK_CONTROL) & 0xFF00)
	{
		switch(nChar)
		{
		case VK_C:
			if(!m_bFullScreen)
			{
				//nMenuState = m_pMainMenu->GetMenuState(IDM_FILE_CLOSE, MF_BYCOMMAND);
				//if(nMenuState != MF_GRAYED)
				//{
				//	Close();
				//	SetState();
				//}
			}
			break;

		case VK_O:
			if(!m_bFullScreen)
			{
				//nMenuState = m_pMainMenu->GetMenuState(IDM_FILE_OPEN, MF_BYCOMMAND);
				//if(nMenuState != MF_GRAYED)		
				//{
				//	if(BrowseFile(&m_strPlayFileName))
				//	{
				//		Open();
				//		SetState();
				//	}
				//}
			}
			break;
		
		case VK_S:
			break;

		case VK_T:
			//nMenuState = m_pMainMenu->GetMenuState(IDM_CUT_FILE, MF_BYCOMMAND);
			//if(nMenuState != MF_GRAYED)
			//{
			//	CutFile();
			//}
			break;

		case VK_L:
			Locate();
			break;

		case VK_LEFT:
			GotoStart();
			break;

		case VK_RIGHT:
			GotoEnd();
			break;
		
		case VK_ONE:
			if(m_enumState != State_Stop)
				ViewZoom(IDM_VIEW_ZOOM_50);
			break;

		case VK_TWO:
			if(m_enumState != State_Stop)
				ViewZoom(IDM_VIEW_ZOOM_100);
			break;

		case VK_THREE:
			if(m_enumState != State_Stop)
				ViewZoom(IDM_VIEW_ZOOM_200);
			break;

		default:
			break;
		}
	}

	else
	{
		switch(nChar)
		{
		case VK_ESCAPE:
			//if(m_bFullScreen)
				//ViewFullScreen();
			break;

		case VK_SPACE:
			if(m_enumState == State_Play)
			{
				Pause();
				SetState();
			}
			else if(m_enumState == State_Pause || m_enumState == State_Stop)
			{
				Play();
				SetState();
			}
			break;
		
		case VK_LEFT:
			if(m_enumState != State_Stop)
			{
				StepBackward();
				SetState();
			}
			break;

		case VK_RIGHT:
			if(m_enumState != State_Stop)
			{
				StepForward();
				SetState();
			}
			break;

		case VK_UP:
			AdjustSound(TRUE);
			break;

		case VK_DOWN:
			AdjustSound(FALSE);
			break;
		
		case VK_DOT:
			if(m_enumState != State_Close)
			{
				//if(m_bFullScreen)
					//ViewFullScreen();
				
				Stop();
				SetState();
			}
			break;

		default:
			break;
		}
	}

	CDialog::OnKeyDown(nChar, nRepCnt, nFlags);
}

///////////////////////////////////////////////////////////////////////////
//Function: Voluem and progress.
///////////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	// TODO: Add your message handler code here and/or call default
	DWORD nTime;
	int   nPlayPos;
	switch(GetWindowLong(pScrollBar->m_hWnd, GWL_ID))
	{
	/////////////////////////////////////////////////////////////////
	//progress slider
	case IDC_PLAY_SLIDER:
		if(m_bStreamType)
			break;
		nPlayPos = m_PlaySlider.GetScrollPos();
		if( abs(nPlayPos - m_nPrePlayPos) < 3 )
			break;

#ifdef _FILE_POS
		NAME(PlayM4_SetPlayPos)(PORT, (float)nPlayPos/(float)PLAYER_SLIDER_MAX);
#else
		nTime = nPlayPos * 1000 / PLAYER_SLIDER_MAX * m_dwMaxFileTime;
		TRACE("Set time ex \n");
		NAME(PlayM4_SetPlayedTimeEx)(PORT,nTime);
		TRACE("set time ex ok!\n");
#endif
//		DrawStatus();
		break;

	///////////////////////////////////////////////////////////////
	//sound slider;
	case IDC_SOUND_SLIDER:
#ifdef _WAVE_ADJ
		NAME(PlayM4_AdjustWaveAudio)(PORT, m_SoundSlider.GetPos());
#else
		NAME(PlayM4_SetVolume)(PORT,m_SoundSlider.GetPos());
#endif
		break;

	default:
		break;
	}
	
	CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}

/////////////////////////////////////////////////////////////////////
//Called when u double click the left button
/////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	//CPoint dpoint;
	//CRect  vwrect;
	//GetCursorPos(&dpoint);	

	//m_ctrlVideoPic.GetWindowRect(&vwrect);
	//if( ( m_enumState == State_Play || m_enumState == State_Pause) && vwrect.PtInRect(dpoint))
	//	ViewFullScreen();
		
	CDialog::OnLButtonDblClk(nFlags, point);
}


/////////////////////////////////////////////////////////////////////
//Timer funtion
/////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	if(nIDEvent==PLAY_TIMER)
	{
		DrawStatus();
	}
	CDialog::OnTimer(nIDEvent);
}




/////////////////////////////////////////////////////////////////////
//Adjust control allign function
/////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnSize(UINT nType, int cx, int cy) 
{
	CDialog::OnSize(nType, cx, cy);
	// TODO: Add your message handler code here

	if(m_ctrlVideoPic.GetSafeHwnd())
	{
		SortControl();
	}
}


/////////////////////////////////////////////////////////////////////
// Function: Limit the window size.
/////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI) 
{
	// TODO: Add your message handler code here and/or call default
	lpMMI->ptMinTrackSize.x = WIDTH/2 + m_dwDlgEdge * 2;				// width
	lpMMI->ptMinTrackSize.y = PANNEL_HEIGHT + m_dwDlgTopSize ;			// height

	CDialog::OnGetMinMaxInfo(lpMMI);
}


///////////////////////////////////////////////////////////////////////////
//Function:Redraw the image when move window.
///////////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnMove(int x, int y) 
{
	CDialog::OnMove(x, y);
	
	// TODO: Add your message handler code here
	NAME(PlayM4_RefreshPlay)(PORT);

	GetWindowRect(&m_rcWindow);
	DWORD dwNewDeviceNum;

	if(m_rcWindow.left < 0)
		return;
	
	if( (DWORD)m_rcWindow.right + (DWORD)m_rcWindow.left > 2 * m_dwScreenWidth )
	{
		if( (DWORD)m_rcWindow.top + (DWORD)m_rcWindow.bottom > 2 * m_dwScreenHeight)
		{
			dwNewDeviceNum = 3;
			m_rcScreen.left  = m_dwScreenWidth;
			m_rcScreen.right = m_dwScreenWidth  * 2;
			m_rcScreen.top   = m_dwScreenHeight;
			m_rcScreen.bottom= m_dwScreenHeight * 2;
		}
		else
		{
			dwNewDeviceNum = 1;
			m_rcScreen.left  = m_dwScreenWidth;
			m_rcScreen.right = m_dwScreenWidth  * 2;
			m_rcScreen.top   = 0;
			m_rcScreen.bottom= m_dwScreenHeight;
		}
	}

	else
	{
		if( (DWORD)m_rcWindow.top + (DWORD)m_rcWindow.bottom > 2 * m_dwScreenHeight)
		{
			dwNewDeviceNum = 2;
			m_rcScreen.left  = 0;
			m_rcScreen.right = m_dwScreenWidth;
			m_rcScreen.top   = m_dwScreenHeight;
			m_rcScreen.bottom= m_dwScreenHeight * 2;
		}
		else
		{
			dwNewDeviceNum = 0;
			m_rcScreen.left  = 0;
			m_rcScreen.right = m_dwScreenWidth;
			m_rcScreen.top   = 0;
			m_rcScreen.bottom= m_dwScreenHeight;
		}
	}
	
	if(dwNewDeviceNum != m_dwOldDeviceNum)
	{
		if(SetDevice(IDM_DEVICE0 + dwNewDeviceNum))
		{
			m_dwOldDeviceNum = dwNewDeviceNum;
		}
	}
}



///////////////////////////////////////////////////////////////////////////
//Function: Called when u click the left mouse button
///////////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
//	CRect rcShow;
//	m_ctrlVideoPic.GetWindowRect(rcShow);
//	ScreenToClient(rcShow);
//
//	if(rcShow.PtInRect(point))
//	{
//		m_StartPoint = point;
//		m_bStartDraw = TRUE;
//		InvalidateRect(m_rcDraw, TRUE);
//		ZeroMemory(&m_rcDraw, sizeof(m_rcDraw));
//	}

	CDialog::OnLButtonDown(nFlags, point);
}

void CPlayerDlg::OnLButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
//	if(m_bStartDraw)
//	{
//		if(m_StartPoint != point)
//		{
//
//			CRect rcShow;
//			m_ctrlVideoPic.GetWindowRect(rcShow);
//			ScreenToClient(rcShow);
//			
//			if( rcShow.PtInRect(point) && (point.x >= m_StartPoint.x) && (point.y >= m_StartPoint.y))
//			{
//				m_rcDraw.left   = m_StartPoint.x;
//				m_rcDraw.top    = m_StartPoint.y;
//				m_rcDraw.right  = point.x;
//				m_rcDraw.bottom = point.y;
//				
//				CDC* pDC = GetDC();
//				pDC->DrawFocusRect(m_rcDraw);
//				ReleaseDC(pDC);
//			
//				LONG nPicWidth  = 352;
//				LONG nPicHeight = 288;
//				NAME(PlayM4_GetPictureSize)(PORT, &nPicWidth, &nPicHeight);
//				m_rcDisplay = GetOnPicRect(rcShow, m_rcDraw, nPicWidth, nPicHeight);
//
//				if(m_pDisplayRegion->m_hWnd)
//					m_pDisplayRegion->PostMessage(WM_DISPLAY_RECT, 0, (long)(&m_rcDisplay));
//			}
//
//		}
//		m_bStartDraw = FALSE;
//	}
	
	CDialog::OnLButtonUp(nFlags, point);
}


//////////////////////////////////////////////////////////////////////
//Function: Close.
//////////////////////////////////////////////////////////////////////
void CPlayerDlg::OnClose() 
{
	// TODO: Add your message handler code here and/or call default
	NAME(PlayM4_Stop)(PORT);
	NAME(PlayM4_CloseFile)(PORT);
	NAME(PlayM4_RealeseDDraw)();

#if (WINVER > 0x0400)
	NAME(PlayM4_ReleaseDDrawDevice)();
#endif
	
	if(m_pSeek != NULL)
	{
		m_pSeek->DestroyWindow();
		delete m_pSeek;
		m_pSeek = NULL;
	}

	if(m_pDisplayRegion != NULL)
	{
		m_pDisplayRegion->DestroyWindow();
		delete m_pDisplayRegion;
		m_pDisplayRegion = NULL;
	}

	if(m_pVideoControl != NULL)
	{
		m_pVideoControl->DestroyWindow();
		delete m_pVideoControl;
		m_pVideoControl = NULL;
	}

	if(m_bConvertAVI)
	{
		g_classAVI.ReleaseResource();
		m_bConvertAVI = FALSE;
	}

	CDialog::OnClose();
}


/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*  user defined message handle begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/

// Function: process the received WM_FILE_END message.
// Para: wParam channel No. lParam reserved；
void CPlayerDlg::PlayMessage(WPARAM wParam, LPARAM lParam)
{
//	if(m_bFullScreen)
//		ViewFullScreen();
	
	//remove the same message.
	MSG msgVal;
	while(PeekMessage(&msgVal, m_hWnd, WM_FILE_END, WM_FILE_END, PM_REMOVE));
	
	if(m_bRepeatPlay)
	{
		TRACE("Process message %d\n", lParam);
		GotoStart();
	}
	
	if(m_bConvertAVI)
	{  
		Stop();
		SetState();
	}

}

// when enc changed got this message
void CPlayerDlg::EncChangeMessage(WPARAM wParam, LPARAM lParam)
{
	MSG msgVal;
	while(PeekMessage(&msgVal,m_hWnd,WM_ENC_CHANGE,WM_ENC_CHANGE,PM_REMOVE));

	//if(m_bFullScreen)
		//ViewFullScreen();

	SetWindowSize();
	Sleep(1);
}

void CPlayerDlg::VideoCtrlOK(WPARAM wParam, LPARAM lParam)
{
	m_pVideoControl->DestroyWindow();
	//if(m_enumState == State_Pause || m_enumState == State_Play)
		//m_pMainMenu->EnableMenuItem(IDM_VIDEO_CONTROL, MF_ENABLED);
}

// when u click the OK button on the seeking dialog, got this message
void CPlayerDlg::SeekOk(WPARAM wParam, LPARAM lParam)
{
	m_pSeek->DestroyWindow();
	//if(m_enumState == State_Pause || m_enumState == State_Play)
		//m_pMainMenu->EnableMenuItem(IDM_SEEK,MF_ENABLED);
}

// when u click the OK button on the display dialog, got this message
void CPlayerDlg::DisplayOk(WPARAM wParam, LPARAM lParam)
{
	if (wParam == 0) {
		m_ctrlBtnCapPic.EnableWindow(TRUE);
		m_ctrlBtnSound.EnableWindow(TRUE);	
		m_ctrlBtnSlow.EnableWindow(TRUE);
		m_ctrlBtnFast.EnableWindow(TRUE);
		m_ctrlBtnGStart.EnableWindow(TRUE);
		m_ctrlBtnGEnd.EnableWindow(TRUE);
		m_ctrlBtnStop.EnableWindow(TRUE);
		m_ctrlBtnPlay.EnableWindow(TRUE);
		m_ctrlBtnPause.EnableWindow(TRUE);	
		m_ctrlStepBackward.EnableWindow(TRUE);
		m_ctrlStepForward.EnableWindow(TRUE);
 		//m_pMainMenu->EnableMenuItem(2, MF_ENABLED|MF_BYPOSITION);
		Play();
		SetState();
	}
	if (wParam == 1) {
		Pause();
		SetState();
	}
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*  user defined message handle over
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/



/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*  callback function begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/	

// Function:The call back funtion for capture image!
void CALLBACK DisplayCBFun(long nPort,\
						   char * pBuf,long nSize,\
						   long nWidth,long nHeight,\
						   long nStamp,long nType,long nReceaved)
{

}

// Function: The dec call back funtion.
void CALLBACK DecCBFun(long nPort,char * pBuf,long nSize,
					   FRAME_INFO * pFrameInfo, 
					   long nUser,long nReserved2)
{
	TRACE("nPort=%d, TYPE=%d; Width=%d; Height=%d\n", nPort, pFrameInfo->nType, pFrameInfo->nWidth, pFrameInfo->nHeight);
	
	if ( pFrameInfo->nType == T_YV12 ) 
	{   
		if(g_classAVI.IsWriteAVIHdr())
		{
			g_classAVI.SetFPS(pFrameInfo->nFrameRate);
			g_classAVI.WriteHeaders();
		}

		g_classAVI.AddFileToAVI(pBuf, nSize);

		if(g_classAVI.IsExceedMaxFileLen())
		{
			SendMessage(AfxGetApp()->GetMainWnd()->m_hWnd,WM_FILE_END,PORT,0);		   
		}	
	}

	Sleep(1);
}

// Funtion:The source buffer call back funtion.
void CALLBACK SourceBufFun(long nPort,DWORD nBufSize,DWORD dwUser,void*pContext)
{
	
	CPlayerDlg* pOwner = (CPlayerDlg*)dwUser;
	// do after play!
	if( (pOwner->m_enumState == State_Close) || (pOwner->m_enumState == State_Stop) )
		return ;
	NAME(PlayM4_ResetSourceBufFlag)(nPort);
	if(pOwner->m_bFileEnd)
	{
		
		PostMessage(pOwner->m_hWnd, WM_FILE_END, PORT, 0);
		pOwner->m_bFileEnd = FALSE;
	}
	else
		SetEvent(pOwner->m_hEventInput);
}

// Functon:File reference call back function.
void CALLBACK FileRefDone(DWORD nReserved,DWORD nUser)
{
	CPlayerDlg* pOwner = (CPlayerDlg*)nUser;
	pOwner->m_bFileRefCreated = TRUE;
	//pOwner->m_pMainMenu->EnableMenuItem(IDM_CUT_FILE,MF_ENABLED);
	//pOwner->m_pMainMenu->EnableMenuItem(IDM_SEEK,MF_ENABLED);
	TRACE("File reference created!\n");
}

// Functon:File Verify call back function.
/*
void CALLBACK VerifyFun(long nPort, FRAME_POS * pFilePos, DWORD bIsVideo,  DWORD nUser)
{
//	TRACE("File have been changed at: pos = 0x%X; time(s) = %d, frameNum = %d; IsVideo = %d\n",
//		pFilePos->nFilePos, pFilePos->nFrameTime/1000, pFilePos->nFrameNum, bIsVideo);
	CString abstime;
	CString str;
	if (pFilePos->pErrorTime )
	{
		abstime.Format("%02d-%02d-%02d %02d:%02d:%02d",pFilePos->pErrorTime->wYear, pFilePos->pErrorTime->wMonth,
			pFilePos->pErrorTime->wDay, pFilePos->pErrorTime->wHour, pFilePos->pErrorTime->wMinute, pFilePos->pErrorTime->wSecond);
	}
	str.Format("file error at pos=0x%X, time(s) =%d,frameNum=%d,isVideo=%d, \
		errorframe at%d,lostframe=%d,lostdata=%d,time=%s\n",	\
		pFilePos->nFilePos, pFilePos->nFrameTime/1000, pFilePos->nFrameNum, bIsVideo,	\
		pFilePos->nErrorFrameNum, pFilePos->nErrorLostFrameNum, pFilePos->nErrorFrameSize, abstime);
	TRACE(str); 
}
*/

// Functon:Wave data call back function.
void CALLBACK WaveCBFun(long nPort, char * pAudioBuf, long nSize, long nStamp, long nType, long nUser)
{
	//TRACE("Wave data, nPort = %d, nSize = %d, nStamp = %d, nType = %d\n", nPort, nSize, nStamp, nType);
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*  callback function begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/



///////////////////////////////////////////////////////////////////////
// Function: input stream thread.
////////////////////////////////////////////////////////////////////////
#define BUF_SIZE 4096
DWORD WINAPI InputStreamThread( LPVOID lpParameter)
{
	CPlayerDlg* pOwner = (CPlayerDlg*)lpParameter;
	HANDLE hMulEvents[2];
	hMulEvents[0] = pOwner->m_hEventKill;
	hMulEvents[1] = pOwner->m_hEventInput;
	BYTE pBuf[BUF_SIZE];
	DWORD nRealRead;
	BOOL bBufFull = FALSE;
	while(WAIT_OBJECT_0 != WaitForMultipleObjects(2, hMulEvents, FALSE, INFINITE))
	{
		if(!bBufFull)
		{
			// TRACE("Read file and put it input into the stream buffer.\n");

			if(!(ReadFile(pOwner->m_hStreamFile, pBuf, BUF_SIZE, &nRealRead, NULL) && (nRealRead == BUF_SIZE)))
			{
				//File end;
				pOwner->m_bFileEnd = TRUE;
				bBufFull = FALSE;
				ResetEvent(pOwner->m_hEventInput);
			}
		}
		if(!NAME(PlayM4_InputData)(PORT, pBuf, BUF_SIZE))
		{
			bBufFull = TRUE;
			ResetEvent(pOwner->m_hEventInput);
		}
		else
			bBufFull = FALSE;
	}
	return 1;
}



/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*  assistant operation begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
// open/close file or stream
// browse file and get the file path
BOOL CPlayerDlg::BrowseFile(CString *strFileName)
{
#ifdef _FOR_HIKPLAYM4_DLL_
	CFileDialog dlg(TRUE, 
					"mpg",
					NULL, 
					OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
					"Hikvision文件(*.mp4;*.264)|*.mp4;*.264|所有文件(*.*)|*.*||", this);
#else
	CFileDialog dlg(TRUE, 
				"mpg",
				NULL, 
				OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
				"文件(*.mp4;*.264)|*.mp4;*.264|所有文件(*.*)|*.*||", this);
#endif

	if(dlg.DoModal() == IDCANCEL)
	{
		return FALSE;
	}
	*strFileName = dlg.GetPathName();
	return TRUE;
}

// open file and play
void CPlayerDlg::OpenFile()
{
	CString csError;

	TRACE("Open FileName Is: %s", m_strPlayFileName);

	NAME(PlayM4_SetFileRefCallBack)(PORT, FileRefDone, (DWORD)this);
//	NAME(PlayM4_SetVerifyCallBack)(PORT, 0, 0xffffffff, VerifyFun, (DWORD) this); // verify the whole file;
	if(!NAME(PlayM4_OpenFile)(PORT, m_strPlayFileName.GetBuffer(m_strPlayFileName.GetLength())))
	{
		m_strPlayFileName = _T("");
		csError.Format("Open file failed(%d)",NAME(PlayM4_GetLastError)(PORT));
		MessageBox(csError);
		
		throw 0;
	}
	
	// try overlay mode!
	//NAME(PlayM4_SetOverlayMode)(PORT, TRUE, RGB(255,0,255));
	// try flip overlay mode
//	NAME(PlayM4_SetOverlayFlipMode)(PORT, TRUE);

	m_dwMaxFileTime = NAME(PlayM4_GetFileTime)(PORT);
	if(!m_dwMaxFileTime)
	{
		csError.Format("File seconds is zero");
		MessageBox(csError);
		throw 0;
	}

	m_dwDisplayHour		= m_dwMaxFileTime/3600;
	m_dwDisplayMinute   = (m_dwMaxFileTime % 3600) / 60;
	m_dwDisplaySecond   = m_dwMaxFileTime % 60;
	m_dwTotalFrames		= NAME(PlayM4_GetFileTotalFrames)(PORT);

	//if(m_bConvertAVI)
	//{
	//	AVI_CONVERT_PARA strParam;
	//	long dwHeight, dwWidth;
	//	NAME(PlayM4_GetPictureSize)(PORT, &dwWidth, &dwHeight);
	//	strParam.dwFrameWidth  = MOD16(dwWidth);
	//	strParam.dwFrameHeight = MOD16(dwHeight);
	//	strParam.dwFrameSize   = strParam.dwFrameWidth * strParam.dwFrameHeight *3/2;
	//	strParam.dwTotalFrames = m_dwTotalFrames;

	//	BOOL bInitAVI = g_classAVI.InitResource(&strParam, m_strSaveAVIPath);
	//	if(!bInitAVI)
	//	{
	//		csError.Format("Init AVI Resource failed!");
	//		MessageBox(csError);
	//		g_classAVI.ReleaseResource();
	//		m_bConvertAVI = FALSE;
	//	}
	//}
	// If you want to change the display buffer. Do hear!
	// NAME(PlayM4_SetDisplayBuf)(PORT,25);
	Play();

	SetWindowText((LPCTSTR) m_strPlayFileName);
}

// close file
void CPlayerDlg::CloseFile()
{
	if (m_pDisplayRegion->m_bValid) 
	{
		m_pDisplayRegion->DestroyWindow();
		//m_pMainMenu->EnableMenuItem(2, MF_ENABLED|MF_BYPOSITION);
		//m_pMainMenu->EnableMenuItem(IDM_SETDISPLAY, MF_ENABLED);		
	}
	Stop();
	NAME(PlayM4_CloseFile)(PORT);
	
	m_enumState = State_Close;
	m_bOpen = FALSE;
	m_bFileRefCreated =	FALSE;	
}

// Funtion: Open the file by stream type and play it
void CPlayerDlg::OpenStream()
{
	m_dwDisplayHour		= 0;
	m_dwDisplayMinute   = 0;
	m_dwDisplaySecond   = 0;
	m_dwTotalFrames     = 0;
	m_bFileEnd          = FALSE;
	

	m_hStreamFile = CreateFile(m_strPlayFileName,
							   GENERIC_READ,
							   FILE_SHARE_READ,
							   NULL,
							   OPEN_EXISTING,
							   FILE_ATTRIBUTE_NORMAL,
							   NULL);
	if(m_hStreamFile == INVALID_HANDLE_VALUE)
	{
		MessageBox("Open file failed");
		throw 0;
	}
	m_dwMaxFileSize = ::GetFileSize(m_hStreamFile, NULL);
	NAME(PlayM4_SetSourceBufCallBack)(PORT, 10000, SourceBufFun, (DWORD)this, NULL);
	NAME(PlayM4_SetStreamOpenMode)(PORT, STREAME_FILE);
	m_dwHeadSize = NAME(PlayM4_GetFileHeadLength)();
	PBYTE pBuf = NULL;
	char csError[50];

	DWORD dw;
	m_hThread	  = NULL;
	m_hEventInput = NULL;
	m_hEventKill  = NULL;

	m_hThread	  =	CreateThread(NULL,0, LPTHREAD_START_ROUTINE (InputStreamThread),this,0,&dw);
	m_hEventInput =	CreateEvent(NULL,TRUE,FALSE,NULL);
	m_hEventKill  =	CreateEvent(NULL,FALSE,FALSE,NULL);
	if( !(m_hThread&&m_hEventInput&&m_hEventKill) )
	{
		MessageBox("Create thread failed");
		throw 0;
	}
	pBuf = new BYTE[m_dwHeadSize];
	if(!pBuf)
	{
		MessageBox("Alloc memory failed");
		throw 0;
	}
	DWORD nRealRead;
	ReadFile(m_hStreamFile, pBuf, m_dwHeadSize, &nRealRead, NULL);
	if(nRealRead != m_dwHeadSize)
	{
		MessageBox("File is too small");
		delete []pBuf;
		pBuf = NULL;
		throw 0;
	}

	if(!NAME(PlayM4_OpenStream)(PORT, pBuf, m_dwHeadSize, 200000))
	{
		sprintf(csError, "Open stream failed(%d)", NAME(PlayM4_GetLastError)(PORT));
		MessageBox(csError);
		delete []pBuf;
		pBuf = NULL;
		throw 0;
	}

	// try overlay mode!
	NAME(PlayM4_SetOverlayMode)(PORT, TRUE, RGB(255,0,255));
	// try flip overlay mode
//	NAME(PlayM4_SetOverlayFlipMode)(PORT, TRUE);
	
	Play();
}


// Function:Close the stream.
void CPlayerDlg::CloseStream()
{
	Stop();
	NAME(PlayM4_CloseStream)(PORT);
	if(m_hStreamFile)
	{
		CloseHandle(m_hStreamFile);
		m_hStreamFile = NULL;
	}
	
	if(m_hThread)
	{
		SetEvent(m_hEventKill);
		DWORD dwStatus;
		for(int i = 0; i < 5; i++)
		{
			if(!::GetExitCodeThread(m_hThread, &dwStatus)|| (i == 4) )
				{
					TerminateThread(m_hThread, 0);
					TRACE("GetExitCode option error!-decodethread\n");
				}
				else
				{
					if(dwStatus == STILL_ACTIVE)
					{
						SetEvent(m_hEventKill);
						Sleep(2);
					}
					else
						break;
				}
		}
		CloseHandle(m_hThread);
		m_hThread = NULL;
	}
	if(m_hEventInput)
	{
		CloseHandle(m_hEventInput);
		m_hEventInput = NULL;
	}
	if(m_hEventKill)
	{
		CloseHandle(m_hEventKill);
		m_hEventKill = NULL;
	}
	
	m_enumState = State_Close;
	m_bOpen = FALSE;
	m_bFileRefCreated =	FALSE;		
}

// set play state
// Funtion: Draw the status .
void CPlayerDlg::DrawStatus()
{
		DWORD nCurrentTime = NAME(PlayM4_GetPlayedTime)(PORT);
		//TRACE("Get time is:%d\n",nCurrentTime);			
		DWORD nHour   = (nCurrentTime / 3600) % 24;
		DWORD nMinute = (nCurrentTime % 3600) / 60;
		DWORD nSecond = nCurrentTime % 60;
		int nPos = 0;
		if(m_bStreamType)
		{
			DWORD nFilePos = SetFilePointer(m_hStreamFile, 0, 0, FILE_CURRENT);
			nPos = nFilePos * PLAYER_SLIDER_MAX / m_dwMaxFileSize;
		}
		else
		{
#ifdef _FILE_POS
		float fPos = NAME(PlayM4_GetPlayPos)(PORT);
		nPos = int(fPos * PLAYER_SLIDER_MAX);
		
#else
		if( m_dwMaxFileTime>0 )
			nPos = nCurrentTime * PLAYER_SLIDER_MAX / m_dwMaxFileTime;
			
#endif
		}
		
		DWORD nCurrentFrame = NAME(PlayM4_GetCurrentFrameNum)(PORT);

		TRACE("nCurrentFrame %d----------nCurrentTime %d--------------\n", nCurrentFrame, nCurrentTime);
		if(m_nSpeed > 0)
			m_strPlayStateText.Format("速度 X %d            %d/%d  %02d:%02d:%02d/%02d:%02d:%02d", GetSpeedModulus(), nCurrentFrame, m_dwTotalFrames, nHour, nMinute, nSecond, m_dwDisplayHour,m_dwDisplayMinute,m_dwDisplaySecond);
		else if(m_nSpeed == 0)
			m_strPlayStateText.Format("正常速度          %d/%d  %02d:%02d:%02d/%02d:%02d:%02d", nCurrentFrame, m_dwTotalFrames, nHour, nMinute, nSecond, m_dwDisplayHour,m_dwDisplayMinute,m_dwDisplaySecond);
		else
			m_strPlayStateText.Format("速度 / %d            %d/%d  %02d:%02d:%02d/%02d:%02d:%02d", GetSpeedModulus(), nCurrentFrame, m_dwTotalFrames, nHour, nMinute, nSecond, m_dwDisplayHour,m_dwDisplayMinute,m_dwDisplaySecond);

		if(m_bConvertAVI)
			m_strPlayStateText.Format("Converting……        %d/%d  %02d:%02d:%02d/%02d:%02d:%02d", nCurrentFrame, m_dwTotalFrames, nHour, nMinute, nSecond, m_dwDisplayHour, m_dwDisplayMinute, m_dwDisplaySecond);     

		m_ctrlPlayText.ShowText(m_strPlayStateText);

		if(m_nPrePlayPos == nPos)
			return;
		//adjust the slider.
		INT nAdjust = (m_nPrePlayPos < nPos) ? 1 : 0;
		m_PlaySlider.SetScrollPos(nPos + nAdjust);
		m_nPrePlayPos = nPos;
		
		// test
		// TRACE("Current frame rate:%d\n",NAME(PlayM4_GetCurrentFrameRate)(PORT));
		// TRACE("Current time use ms:%d\n",NAME(PlayM4_GetPlayedTimeEx)(PORT));
	
}

// set state
void CPlayerDlg::SetState()
{
	//return;
	int i;
	switch(m_enumState)
	{
	case State_Close:
		
		// button state

		m_ctrlBtnPlay.SetIcon(IDI_PLAY_DISABLE);
		m_ctrlBtnPlay.EnableWindow(FALSE);
		m_ctrlBtnPlay.SetCheck(0);

		m_ctrlBtnPause.SetIcon(IDI_PAUSE_DISABLE);
		m_ctrlBtnPause.EnableWindow(FALSE);
		m_ctrlBtnPause.SetCheck(0);

		m_ctrlBtnStop.SetIcon(IDI_STOP_DISABLE);
		m_ctrlBtnStop.EnableWindow(FALSE);
		m_ctrlBtnStop.SetCheck(0);

		m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_DISABLE);
		m_ctrlBtnGStart.EnableWindow(FALSE);

		m_ctrlBtnSlow.SetIcon(IDI_FASTBACKWARD_DISABLE);
		m_ctrlBtnSlow.EnableWindow(FALSE);

		m_ctrlBtnFast.SetIcon(IDI_FASTFORWARD_DISABLE);
		m_ctrlBtnFast.EnableWindow(FALSE);

		m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_DISABLE);
		m_ctrlBtnGEnd.EnableWindow(FALSE);

		m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_DISABLE);
		m_ctrlStepBackward.EnableWindow(FALSE);

		m_ctrlStepForward.SetIcon(IDI_STEPFORWARD_DISABLE);
		m_ctrlStepForward.EnableWindow(FALSE);
		
		m_ctrlBtnCapPic.SetIcon(IDI_CAPPIC_DISABLE);
		m_ctrlBtnCapPic.EnableWindow(FALSE);
		
		m_ctrlBtnSound.SetIcon(IDI_SOUND_DISABLE);
		m_ctrlBtnSound.EnableWindow(FALSE);
		
		// menu state
		//m_pMainMenu->EnableMenuItem(IDM_FILE_CLOSE, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_CUT_FILE, MF_GRAYED | MF_DISABLED);

		//for(i = 0; i < 3; i++)
		//{
		//	m_pMainMenu->CheckMenuItem(IDM_VIEW_ZOOM_50 + i, MF_UNCHECKED);
		//}
		//m_pMainMenu->CheckMenuItem(IDM_VIEW_ZOOM_100, MF_CHECKED);
		//m_pMainMenu->GetSubMenu(1)->EnableMenuItem(1, MF_DISABLED|MF_GRAYED|MF_BYPOSITION);
		//m_pMainMenu->EnableMenuItem(IDM_VIEW_FULLSCREEN, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_INFO, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_SETDISPLAY, MF_GRAYED | MF_DISABLED);

		//m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_VIDEO_CONTROL, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_PLAY_PAUSE, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STOP, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_GOTOEND, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_GOTOSTART, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPBACKWARD, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPFORWARD, MF_GRAYED | MF_DISABLED);


		//m_pMainMenu->EnableMenuItem(IDM_PREVIEW50, MF_ENABLED);
		//if(m_bHighFluid)
		//	m_pMainMenu->CheckMenuItem(IDM_PREVIEW50, MF_CHECKED);
		//else
		//	m_pMainMenu->CheckMenuItem(IDM_PREVIEW50, MF_UNCHECKED);

		//m_pMainMenu->EnableMenuItem(IDM_STREAM_TYPE, MF_ENABLED);
		//for(i=0; i<2; i++)
		//{
		//	m_pMainMenu->CheckMenuItem(IDM_TIMER1 + i, MF_UNCHECKED);
		//}
		//m_pMainMenu->CheckMenuItem(IDM_TIMER1, MF_CHECKED);
		//m_pMainMenu->GetSubMenu(3)->EnableMenuItem(7, MF_ENABLED|MF_BYPOSITION);

		
		// scroll state	
		m_PlaySlider.SetScrollPos(0);
		m_PlaySlider.EnableWindow(FALSE);

#ifdef _WAVE_ADJ
		m_SoundSlider.SetPos(0);
#else
		m_SoundSlider.SetPos(0xffff>>1);
#endif
		m_SoundSlider.EnableWindow(FALSE);

		if((HBITMAP)m_HikvisionBmp != m_ctrlVideoPic.GetBitmap())
			m_ctrlVideoPic.SetBitmap(m_HikvisionBmp);
		
		//InitWindowSize(WIDTH,HEIGHT_PAL);

		break;

	case State_Play:
		m_ctrlBtnPlay.SetIcon(IDI_PLAY_CHECK);
		m_ctrlBtnPlay.EnableWindow(TRUE);
		m_ctrlBtnPlay.SetCheck(1);

		m_ctrlBtnPause.SetIcon(IDI_PAUSE_ENABLE);
		m_ctrlBtnPause.EnableWindow(TRUE);
		m_ctrlBtnPause.SetCheck(0);

		m_ctrlBtnStop.SetIcon(IDI_STOP_ENABLE);
		m_ctrlBtnStop.EnableWindow(TRUE);
		m_ctrlBtnStop.SetCheck(0);

		if(m_bStreamType)
		{
			m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_DISABLE);
			m_ctrlBtnGStart.EnableWindow(FALSE);

			m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_DISABLE);
			m_ctrlBtnGEnd.EnableWindow(FALSE);

			m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_DISABLE);
			m_ctrlStepBackward.EnableWindow(FALSE);
		}
		
		
		else
		{
			m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_ENABLE);
			m_ctrlBtnGStart.EnableWindow(TRUE);

			m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_ENABLE);
			m_ctrlBtnGEnd.EnableWindow(TRUE);

			m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_ENABLE);
			m_ctrlStepBackward.EnableWindow(TRUE);
		}
	

		m_ctrlBtnSlow.SetIcon(IDI_FASTBACKWARD_ENABLE);
		m_ctrlBtnSlow.EnableWindow(TRUE);

		m_ctrlBtnFast.SetIcon(IDI_FASTFORWARD_ENABLE);
		m_ctrlBtnFast.EnableWindow(TRUE);

		m_ctrlStepForward.SetIcon(IDI_STEPFORWARD_ENABLE);
		m_ctrlStepForward.EnableWindow(TRUE);

		m_ctrlBtnCapPic.SetIcon(IDI_CAPPIC_AT, IDI_CAPPIC_ENABLE);
		m_ctrlBtnCapPic.EnableWindow(TRUE);

		m_ctrlBtnSound.EnableWindow(TRUE);
		if(m_bSound)
			m_ctrlBtnSound.SetIcon(IDI_SOUND_ENABLE);
		else
			m_ctrlBtnSound.SetIcon(IDI_SOUND_DISABLE);

		
		// menu state
		//m_pMainMenu->EnableMenuItem(IDM_FILE_CLOSE, MF_ENABLED);

		//if(m_bFileRefCreated)
		//{
		//	m_pMainMenu->EnableMenuItem(IDM_CUT_FILE, MF_ENABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_ENABLED);
		//}

		//else
		//{
		//	m_pMainMenu->EnableMenuItem(IDM_CUT_FILE, MF_GRAYED | MF_DISABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_GRAYED | MF_DISABLED);
		//}

		//m_pMainMenu->GetSubMenu(1)->EnableMenuItem(1, MF_ENABLED | MF_BYPOSITION);
		//m_pMainMenu->EnableMenuItem(IDM_VIEW_FULLSCREEN, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_INFO, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_SETDISPLAY, MF_ENABLED);
		//
		//m_pMainMenu->EnableMenuItem(IDM_VIDEO_CONTROL, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_PLAY_PAUSE, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STOP, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPFORWARD, MF_ENABLED);
		//
		//m_pMainMenu->EnableMenuItem(IDM_PREVIEW50, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STREAM_TYPE, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->GetSubMenu(3)->EnableMenuItem(7, MF_DISABLED|MF_GRAYED|MF_BYPOSITION);
	
		//if(m_bStreamType)
		//{
		//	m_pMainMenu->EnableMenuItem(IDM_GOTOEND, MF_GRAYED | MF_DISABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_GOTOSTART, MF_GRAYED | MF_DISABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_STEPBACKWARD, MF_GRAYED | MF_DISABLED);
		//}

		//else
		//{
		//	m_pMainMenu->EnableMenuItem(IDM_GOTOEND, MF_ENABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_GOTOSTART, MF_ENABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_STEPBACKWARD, MF_ENABLED);
		//}

		// scroll state			
		if(m_bStreamType)
			m_PlaySlider.EnableWindow(FALSE);
		else
			m_PlaySlider.EnableWindow(TRUE);
		m_SoundSlider.EnableWindow(TRUE);
	
		if((HBITMAP)m_OverlayBmp != m_ctrlVideoPic.GetBitmap())
			m_ctrlVideoPic.SetBitmap(m_OverlayBmp);

		break;

	case State_Pause:
		m_ctrlBtnPlay.SetIcon(IDI_PLAY_ENABLE);
		m_ctrlBtnPlay.EnableWindow(TRUE);
		m_ctrlBtnPlay.SetCheck(0);

		m_ctrlBtnPause.SetIcon(IDI_PAUSE_CHECK);
		m_ctrlBtnPause.EnableWindow(TRUE);
		m_ctrlBtnPause.SetCheck(1);

		m_ctrlBtnStop.SetIcon(IDI_STOP_ENABLE);
		m_ctrlBtnStop.EnableWindow(TRUE);
		m_ctrlBtnStop.SetCheck(0);


		if(m_bStreamType)
		{
			m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_DISABLE);
			m_ctrlBtnGStart.EnableWindow(FALSE);

			m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_DISABLE);
			m_ctrlBtnGEnd.EnableWindow(FALSE);

			m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_DISABLE);
			m_ctrlStepBackward.EnableWindow(FALSE);
		}
		
		
		else
		{
			m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_ENABLE);
			m_ctrlBtnGStart.EnableWindow(TRUE);

			m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_ENABLE);
			m_ctrlBtnGEnd.EnableWindow(TRUE);

			m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_ENABLE);
			m_ctrlStepBackward.EnableWindow(TRUE);
		}
	

		m_ctrlBtnSlow.SetIcon(IDI_FASTBACKWARD_ENABLE);
		m_ctrlBtnSlow.EnableWindow(TRUE);

		m_ctrlBtnFast.SetIcon(IDI_FASTFORWARD_ENABLE);
		m_ctrlBtnFast.EnableWindow(TRUE);

		m_ctrlStepForward.SetIcon(IDI_STEPFORWARD_ENABLE);
		m_ctrlStepForward.EnableWindow(TRUE);

		m_ctrlBtnCapPic.SetIcon(IDI_CAPPIC_AT, IDI_CAPPIC_ENABLE);
		m_ctrlBtnCapPic.EnableWindow(TRUE);
		
		break;

	case State_Stop:
		m_ctrlBtnPlay.SetIcon(IDI_PLAY_ENABLE);
		m_ctrlBtnPlay.EnableWindow(TRUE);
		m_ctrlBtnPlay.SetCheck(0);

		m_ctrlBtnPause.SetIcon(IDI_PAUSE_ENABLE);
		m_ctrlBtnPause.EnableWindow(TRUE);
		m_ctrlBtnPause.SetCheck(0);

		m_ctrlBtnStop.SetIcon(IDI_STOP_CHECK);
		m_ctrlBtnStop.EnableWindow(TRUE);
		m_ctrlBtnStop.SetCheck(1);

		m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_DISABLE);
		m_ctrlBtnGStart.EnableWindow(FALSE);

		m_ctrlBtnSlow.SetIcon(IDI_FASTBACKWARD_ENABLE);
		m_ctrlBtnSlow.EnableWindow(TRUE);

		m_ctrlBtnFast.SetIcon(IDI_FASTFORWARD_ENABLE);
		m_ctrlBtnFast.EnableWindow(TRUE);

		m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_DISABLE);
		m_ctrlBtnGEnd.EnableWindow(FALSE);

		m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_DISABLE);
		m_ctrlStepBackward.EnableWindow(FALSE);

		m_ctrlStepForward.SetIcon(IDI_STEPFORWARD_DISABLE);
		m_ctrlStepForward.EnableWindow(FALSE);
		
		m_ctrlBtnCapPic.SetIcon(IDI_CAPPIC_DISABLE);
		m_ctrlBtnCapPic.EnableWindow(FALSE);
		
		// menu state
		//m_pMainMenu->EnableMenuItem(IDM_FILE_CLOSE, MF_ENABLED);

		//if(m_bFileRefCreated)
		//{
		//	m_pMainMenu->EnableMenuItem(IDM_CUT_FILE, MF_ENABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_ENABLED);
		//}

		//else
		//{
		//	m_pMainMenu->EnableMenuItem(IDM_CUT_FILE, MF_DISABLED);
		//	m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_DISABLED);
		//}

		//m_pMainMenu->GetSubMenu(1)->EnableMenuItem(1, MF_DISABLED|MF_GRAYED|MF_BYPOSITION);
		//m_pMainMenu->EnableMenuItem(IDM_VIEW_FULLSCREEN, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_INFO, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_SETDISPLAY, MF_GRAYED | MF_DISABLED);

		//m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_VIDEO_CONTROL, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_PLAY_PAUSE, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STOP, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_GOTOEND, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_GOTOSTART, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPBACKWARD, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPFORWARD, MF_GRAYED | MF_DISABLED);
		//
		//m_pMainMenu->EnableMenuItem(IDM_PREVIEW50, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STREAM_TYPE, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->GetSubMenu(3)->EnableMenuItem(7, MF_DISABLED|MF_GRAYED|MF_BYPOSITION);

		// scroll state
		m_PlaySlider.SetScrollPos(0);
		m_PlaySlider.EnableWindow(FALSE);
		
#ifdef _WAVE_ADJ
		m_SoundSlider.SetPos(0);
#else
		m_SoundSlider.SetPos(0xffff>>1);
#endif
		m_SoundSlider.EnableWindow(FALSE);

		if((HBITMAP)m_HikvisionBmp != m_ctrlVideoPic.GetBitmap())
			m_ctrlVideoPic.SetBitmap(m_HikvisionBmp);

		break;
		
	default:
		break;
	}
	
	SortControl();
	
	UpdateData(FALSE);
	NAME(PlayM4_RefreshPlay)(PORT);
}

// set avi state
void CPlayerDlg::SetAVIState()
{
		// button state

		m_ctrlBtnPlay.SetIcon(IDI_PLAY_DISABLE);
		m_ctrlBtnPlay.EnableWindow(FALSE);
		m_ctrlBtnPlay.SetCheck(0);

		m_ctrlBtnPause.SetIcon(IDI_PAUSE_DISABLE);
		m_ctrlBtnPause.EnableWindow(FALSE);
		m_ctrlBtnPause.SetCheck(0);

		m_ctrlBtnStop.SetIcon(IDI_STOP_ENABLE);
		m_ctrlBtnStop.EnableWindow(TRUE);
		m_ctrlBtnStop.SetCheck(0);

		m_ctrlBtnGStart.SetIcon(IDI_GOTOSTART_DISABLE);
		m_ctrlBtnGStart.EnableWindow(FALSE);

		m_ctrlBtnSlow.SetIcon(IDI_FASTBACKWARD_DISABLE);
		m_ctrlBtnSlow.EnableWindow(FALSE);

		m_ctrlBtnFast.SetIcon(IDI_FASTFORWARD_DISABLE);
		m_ctrlBtnFast.EnableWindow(FALSE);

		m_ctrlBtnGEnd.SetIcon(IDI_GOTOEND_DISABLE);
		m_ctrlBtnGEnd.EnableWindow(FALSE);

		m_ctrlStepBackward.SetIcon(IDI_STEPBACKWARD_DISABLE);
		m_ctrlStepBackward.EnableWindow(FALSE);

		m_ctrlStepForward.SetIcon(IDI_STEPFORWARD_DISABLE);
		m_ctrlStepForward.EnableWindow(FALSE);
		
		m_ctrlBtnCapPic.SetIcon(IDI_CAPPIC_DISABLE);
		m_ctrlBtnCapPic.EnableWindow(FALSE);
		
		m_ctrlBtnSound.SetIcon(IDI_SOUND_DISABLE);
		m_ctrlBtnSound.EnableWindow(FALSE);
		
		// menu state
		//m_pMainMenu->EnableMenuItem(IDM_FILE_CLOSE, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_CUT_FILE, MF_GRAYED | MF_DISABLED);

		//m_pMainMenu->GetSubMenu(1)->EnableMenuItem(1, MF_DISABLED | MF_GRAYED | MF_BYPOSITION);
		//m_pMainMenu->EnableMenuItem(IDM_VIEW_FULLSCREEN, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_INFO, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_SETDISPLAY, MF_GRAYED | MF_DISABLED);

		//m_pMainMenu->EnableMenuItem(IDM_SEEK, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_VIDEO_CONTROL, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_PLAY_PAUSE, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STOP, MF_ENABLED);
		//m_pMainMenu->EnableMenuItem(IDM_GOTOEND, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_GOTOSTART, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPBACKWARD, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STEPFORWARD, MF_GRAYED | MF_DISABLED);

		//m_pMainMenu->EnableMenuItem(IDM_PREVIEW50, MF_GRAYED | MF_DISABLED);
		//m_pMainMenu->EnableMenuItem(IDM_STREAM_TYPE, MF_GRAYED | MF_DISABLED);	
		//m_pMainMenu->GetSubMenu(3)->EnableMenuItem(7, MF_GRAYED | MF_DISABLED | MF_BYPOSITION);

		
		// scroll state	
		m_PlaySlider.SetScrollPos(0);
		m_PlaySlider.EnableWindow(FALSE);


		if((HBITMAP)m_OverlayBmp != m_ctrlVideoPic.GetBitmap())
			m_ctrlVideoPic.SetBitmap(m_OverlayBmp);

}

// get speed modulus to show int the static text control
DWORD CPlayerDlg::GetSpeedModulus()
{
	DWORD dwValue = 0;
	switch(m_nSpeed)
	{
	case 1:
	case -1:
		dwValue = 2;
		break;
	case 2:
	case -2:
		dwValue = 4;
		break;
	case 3:
	case -3:
		dwValue = 8;
		break;
	case 4:
	case -4:
		dwValue = 16;
		break;
	default:
		break;
	}
	return dwValue;
}

// resize the dialog
void CPlayerDlg::SetWindowSize()
{
	CRect rcWin, rcClient;
	GetWindowRect(&rcWin);
	GetClientRect(&rcClient);
	m_dwDlgEdge = (rcWin.Width() - rcClient.Width()) >> 1;
	ClientToScreen(&rcClient);
	m_dwDlgTopSize = rcClient.top - rcWin.top;

	TRACE("init window size!\n");
	NAME(PlayM4_GetPictureSize)(PORT, &m_nWidth, &m_nHeight);
	TRACE("get window size ok\n");

	DWORD nWindowHeight = m_nHeight + PANNEL_HEIGHT + m_dwDlgTopSize + m_dwDlgEdge + 10;
	DWORD nWindowWidth  = m_nWidth + (m_dwDlgEdge << 1);
	MoveWindow(
		(m_dwScreenWidth  -nWindowWidth)  / 2 + m_rcScreen.left,
		(m_dwScreenHeight -nWindowHeight) / 2 + m_rcScreen.top,
		nWindowWidth,
		nWindowHeight,
		TRUE);
	TRACE("exit window size\n");
	//rcClient.right+=200;
	m_ctrlVideoPic.GetClientRect(&rcClient);

}

// Funtion: sort the controls
void CPlayerDlg::SortControl()
{
	TRACE("init SORT\n");

	// if the dialog doesn't support resizing, return;
	if( !(GetStyle() & WS_SIZEBOX) )
		return;

	CRect rcClient, rcVideo;
	
	GetClientRect(&rcClient);
	DWORD x=LEFT_EDGE+10,y=rcClient.bottom-STATE_HEIGHT;
	
	//STATE 
	m_ctrlPlayText.MoveWindow(0,y,rcClient.Width()+1,STATE_HEIGHT,TRUE);


	x=LEFT_EDGE;
	y-=BUTTON_SIZE+STATE_UP;

	//BUTTON
	m_ctrlBtnPlay.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;
	m_ctrlBtnPause.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;
	m_ctrlBtnStop.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;

	x+=INTERVAL;
	GetDlgItem(IDC_INTER1)->MoveWindow(x,y,INTERVAL_SIZE,BUTTON_SIZE,TRUE);
	x+=INTERVAL_SIZE;
	x+=INTERVAL;

	m_ctrlBtnGStart.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;
	m_ctrlBtnSlow.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;
	m_ctrlBtnFast.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;
	m_ctrlBtnGEnd.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;

	x+=INTERVAL;
	GetDlgItem(IDC_INTER2)->MoveWindow(x,y,INTERVAL_SIZE,BUTTON_SIZE,TRUE);
	x+=INTERVAL_SIZE;
	x+=INTERVAL;

	m_ctrlStepBackward.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;

	m_ctrlStepForward.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;

	x+=INTERVAL;
	GetDlgItem(IDC_INTER3)->MoveWindow(x,y,INTERVAL_SIZE,BUTTON_SIZE,TRUE);
	x+=INTERVAL_SIZE;
	x+=INTERVAL;

	m_ctrlBtnCapPic.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);
	x+=BUTTON_SIZE;

	
	//SOUND
	x=rcClient.right-SOUND_SLIDER_WIDTH;
	m_SoundSlider.MoveWindow(x,y+BUTTON_SIZE-SOUND_SLIDER_HEIGHT,SOUND_SLIDER_WIDTH,SOUND_SLIDER_HEIGHT,TRUE);
	x-=BUTTON_SIZE;

	m_ctrlBtnSound.MoveWindow(x,y,BUTTON_SIZE,BUTTON_SIZE,TRUE);

	y-=BUTTON_SIZE+BUTTON_UP;
	//PLAY SLIDER
	x=0;
	GetDlgItem(IDC_PLAY_RECT_SLIDER)->MoveWindow(x,y,rcClient.Width(),PLAY_SLIDER_HEIGHT,TRUE);
	m_PlaySlider.MoveWindowEx(x,y,rcClient.Width(),PLAY_SLIDER_HEIGHT,TRUE);
	y-=PLAY_SLIDER_UP;

	//pic show
	m_ctrlVideoPic.MoveWindow(0,0,rcClient.Width(),y,TRUE);

	NAME(PlayM4_RefreshPlay)(PORT);

	// redraw whole the dialog rect except the video show rect
	m_ctrlVideoPic.GetClientRect(&rcVideo);
	CRect rect;
	rect.left   = rcClient.left;
	rect.top    = rcVideo.bottom;
	rect.right  = rcClient.right;
	rect.bottom = rcClient.bottom;
	InvalidateRect(&rect);
	TRACE("exit SORT\n");
}


// Funtion: Init window size.
void CPlayerDlg::InitWindowSize(DWORD cx,DWORD cy)
{
	TRACE("init window\n");
	CRect rcWin, rcClient;
	GetWindowRect(&rcWin);
	GetClientRect(&rcClient);
	m_dwDlgEdge = (rcWin.Width() - rcClient.Width()) >> 1;
	ClientToScreen(&rcClient);
	m_dwDlgTopSize = rcClient.top - rcWin.top;
	DWORD nWindowHeight = cy + PANNEL_HEIGHT + m_dwDlgTopSize + m_dwDlgEdge + 10;
	DWORD nWindowWidth  = cx + (m_dwDlgEdge << 1);
	
	nWindowHeight = min(nWindowHeight, m_dwScreenHeight);
	nWindowWidth  = min(nWindowWidth,  m_dwScreenWidth);

	MoveWindow(
		(m_dwScreenWidth  - nWindowWidth)/2 + m_rcScreen.left,
		(m_dwScreenHeight - nWindowHeight)/2+ m_rcScreen.top,
		nWindowWidth,
		nWindowHeight,
		TRUE);
	
	SortControl();

	//for the small picture size.The menu will be high. 
	GetWindowRect(&rcWin);
	GetClientRect(&rcClient);
	m_dwDlgEdge = (rcWin.Width() - rcClient.Width()) >> 1;
	ClientToScreen(&rcClient);
	DWORD nTopSize = rcClient.top - rcWin.top;
	if(nTopSize != m_dwDlgTopSize)
	{
		TRACE("re init window!!!!!!\n");
		m_dwDlgTopSize = nTopSize;
		nWindowHeight  = cy + PANNEL_HEIGHT + m_dwDlgTopSize + m_dwDlgEdge + 10;
		nWindowWidth   = cx + (m_dwDlgEdge << 1);
		MoveWindow(
				  (m_dwScreenWidth  - nWindowWidth)  / 2 + m_rcScreen.left,
				  (m_dwScreenHeight - nWindowHeight) / 2 + m_rcScreen.top,
				  nWindowWidth,
				  nWindowHeight,
				  TRUE);
		SortControl();
	}
}


// others
// geton pic rect
CRect CPlayerDlg::GetOnPicRect(CRect rcWnd, CRect rcOnWnd, LONG nPicWidth, LONG nPicHeight)
{
	CRect rcOnPic;
	//LONG nScaleX=rcWnd.Width()
	long nWndX = rcOnWnd.left - rcWnd.left;
	long nWndY = rcOnWnd.top  - rcWnd.top;
	if(nWndX < 0)
		nWndX = 0;
	if(nWndY < 0)
		nWndY = 0;

	rcOnPic.left   = nWndX * nPicWidth  / rcWnd.Width();
	rcOnPic.top    = nWndY * nPicHeight / rcWnd.Height();
	rcOnPic.right  = rcOnPic.left + rcOnWnd.Width()  * nPicWidth/rcWnd.Width();
	rcOnPic.bottom = rcOnPic.top  + rcOnWnd.Height() * nPicHeight/rcWnd.Height();
	
	if(rcOnPic.right > nPicWidth)
		rcOnPic.right = nPicWidth;
	if(rcOnPic.bottom > nPicHeight)
		rcOnPic.bottom = nPicHeight;
	
	return rcOnPic;
}
	
// Funtion: test the capability of your system.
void CPlayerDlg::TestCapability(DWORD nDeviceNum)
{
	CString csCap="";
#if (WINVER > 0x0400)
	int nFlag=NAME(PlayM4_GetCapsEx)(nDeviceNum);
#else
	int nFlag=NAME(PlayM4_GetCaps)();
#endif

	if(!(nFlag&SUPPORT_SSE))
		csCap+="Don't support SSE instruction set;\r\n";
	if(!(nFlag&SUPPORT_DDRAW))
		csCap+="Create DirectDraw faild;\r\n";
	if(!(nFlag&SUPPORT_BLT))
		csCap+="Don't support BLT;\r\n";
	if(!(nFlag&SUPPORT_BLTFOURCC))
		csCap+="Don't support color-space conversions;\r\n";
	if(!(nFlag&SUPPORT_BLTSHRINKX))
		csCap+="Don't support arbitrary shrinking of a surface along the x-axis\r\n";
	if(!(nFlag&SUPPORT_BLTSHRINKY))
		csCap+="Don't supports arbitrary shrinking of a surface along the y-axis (vertically);\r\n";
	if(!(nFlag&SUPPORT_BLTSTRETCHX))
		csCap+="Don't supports arbitrary stretching of a surface along the x-axis;\r\n";
	if(!(nFlag&SUPPORT_BLTSTRETCHY))
		csCap+="Don't supports arbitrary stretching of a surface along the y-axis;\r\n";
	
	if(csCap.GetLength()>0)
	{
		csCap+="If your video adapter chip is made by nVidia,please update the new driver!\r\n";
		MessageBox(csCap,"Warning",MB_OK);
	}
}

void CPlayerDlg::SetDisplayRegion(RECT Rect)
{
	if (m_enumState != State_Pause) {
		return;
	}
	NAME(PlayM4_SetDisplayRegion)(PORT, 0, &Rect, GetDlgItem(IDC_SHOW)->m_hWnd, TRUE);
	UpdateWindow();
 	NAME(PlayM4_RefreshPlayEx)(PORT, 0);
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*  assistant operation over
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/




/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* button operation begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
// play / pause / stop
void CPlayerDlg::Play()
{
	if(m_enumState == State_Play)
		return;
	
	if(m_enumState == State_Pause)
	{
		DWORD nPreSpeed = m_nSpeed;

		m_enumState = State_Play;
		NAME(PlayM4_Pause)(PORT, FALSE);

		// when u called this api, the speed is adjust to normal speed, so we must resume it.
		NAME(PlayM4_Play)(PORT, m_ctrlVideoPic.GetSafeHwnd());
		m_nSpeed = 0;
		ThrowB(IDM_THROW0);
		AdjustSpeed(nPreSpeed);
	}

	else
	{
		m_nSpeed = 0;
		ThrowB(IDM_THROW0);

		if(m_bConvertAVI)
		{
			NAME(PlayM4_SetDecCallBackMend)(PORT, DecCBFun, DWORD(this));
			m_bFileRefCreated = FALSE;
		}

		if(m_bStreamType)
		{
			::SetFilePointer(m_hStreamFile, m_dwHeadSize, 0, FILE_BEGIN);
			NAME(PlayM4_ResetSourceBuffer)(PORT);
			SetEvent(m_hEventInput);
		}

		if(NAME(PlayM4_Play)(PORT, m_ctrlVideoPic.m_hWnd))
		{
			m_enumState = State_Play;

			SetTimer(PLAY_TIMER, 500, NULL);

			NAME(PlayM4_RefreshPlay)(PORT);
		}

		m_bSound = NAME(PlayM4_PlaySound)(PORT);	
	}	
	//if (m_pDisplayRegion->m_bValid) 
	//{
	//	m_pDisplayRegion->Enable(FALSE);
 //	}
}

void CPlayerDlg::Pause()
{
	if(m_enumState == State_Play)
	{
		NAME(PlayM4_Pause)(PORT, TRUE);
		m_enumState = State_Pause;
	}
	if (m_pDisplayRegion->m_bValid) {
		Sleep(50);	
		m_pDisplayRegion->Enable(TRUE);
		m_pDisplayRegion->DrawRectangle();

	}
}

void CPlayerDlg::Stop()
{
	if(m_enumState == State_Stop)
		return;

	KillTimer(PLAY_TIMER);

	// stop sound
	if(NAME(PlayM4_StopSound)())
	{
		m_bSound = FALSE;

		m_ctrlBtnSound.SetIcon(IDI_SOUND_DISABLE);
	}
	
	// stop video
	if(NAME(PlayM4_Stop)(PORT))	
	{
		m_strPlayStateText = "停止";
		m_ctrlPlayText.ShowText(m_strPlayStateText);
	
		if(m_bStreamType)
		{
			ResetEvent(m_hEventInput);
		}
	}	

	if(m_bConvertAVI)
	{
	   g_classAVI.ReleaseResource();
		
	   m_strSaveAVIPath = _T("");
	   m_bConvertAVI = FALSE;    
	}

	m_enumState = State_Stop;
}

// gotostart / slow / fast / gotoend
void CPlayerDlg::GotoStart() 
{
	// TODO: Add your control notification handler code here

	if(m_bFileRefCreated)
		NAME(PlayM4_SetCurrentFrameNum)(PORT, 0);
	else
		NAME(PlayM4_SetPlayPos)(PORT, 0);
}

void CPlayerDlg::GotoEnd() 
{
	// TODO: Add your control notification handler code here
	
	if(m_bFileRefCreated)
	{
		//Note: May create many WM_FILE_END message. The best way is to synchronize the option;
		
		int nEndFrame = m_dwTotalFrames;
		int nCurFrame = NAME(PlayM4_GetCurrentFrameNum)(PORT);
		while(!NAME(PlayM4_SetCurrentFrameNum)(PORT, nEndFrame--))
		{
			//TRACE("FrameNum is :%d\n",nEndFrame);
			if(nEndFrame <= max(0, m_dwTotalFrames - 3))
			{
				NAME(PlayM4_SetCurrentFrameNum)(PORT, nCurFrame);
				break;
			}
		}
	}
	else
	{
		NAME(PlayM4_SetPlayPos)(PORT, 1);
	}

}

void CPlayerDlg::Fast() 
{
	// TODO: Add your control notification handler code here

	// Throw B-Frame ,improve the performance;
	
	if(NAME(PlayM4_Fast)(PORT))
	{
		m_nSpeed ++;
		if(m_nSpeed > 0)
			ThrowB(IDM_THROW2);	
	}	
}

void CPlayerDlg::Slow() 
{
	// TODO: Add your control notification handler code here
	
	if(NAME(PlayM4_Slow)(PORT))
	{
		m_nSpeed --;
		if(m_nSpeed <= 0)
			ThrowB(IDM_THROW0);
	}
}

void CPlayerDlg::AdjustSpeed(int nSpeed)
{
	int nCyc = 0;
	while(m_nSpeed != nSpeed)
	{
		if(nSpeed > m_nSpeed)
		{
			Fast();	
		}

		else if(nSpeed < m_nSpeed)
		{
			Slow();
		}

		nCyc ++;
		if(nCyc >= 10)
			break;
	}
}

// stepback / stepfore / cap picture
void CPlayerDlg::StepBackward() 
{
	// TODO: Add your control notification handler code here

	if(m_bFileRefCreated)
	{
		NAME(PlayM4_OneByOneBack)(PORT);
		m_enumState = State_Pause;
		if (m_pDisplayRegion->m_bValid) {
			Sleep(50);	
			m_pDisplayRegion->Enable(TRUE);
			m_pDisplayRegion->DrawRectangle();

		}
	}

	else
		MessageBox("File reference hasn't been created.", NULL, MB_OK);
}

void CPlayerDlg::StepForward() 
{
	// TODO: Add your control notification handler code here
	
	// you can do it like the followed too.
	// DWORD nCurrentFrame = NAME(PlayM4_GetCurrentFrameNum)(PORT);
	// NAME(PlayM4_SetCurrentFrameNum)(PORT,nCurrentFrame+1);
	ThrowB(IDM_THROW0);          // when step forward one by one, don't throw B frame;
	NAME(PlayM4_OneByOne)(PORT);
    m_enumState = State_Pause;
	if (m_pDisplayRegion->m_bValid) {
		Sleep(50);	
		m_pDisplayRegion->Enable(TRUE);
		m_pDisplayRegion->DrawRectangle();

	}
}

void CPlayerDlg::GetPic(PBYTE pImage, DWORD nBufSize)
{
	CString sFilePath;
	CFile	clsFile;

	DWORD   pImageSize	= 0;
	
	if(m_nCapPicType == 1)
	{
		if( !NAME(PlayM4_GetJPEG)(PORT, pImage, nBufSize, &pImageSize) )
		{
			return;
		}

		if(m_strCapPicPath.Compare(""))
			sFilePath.Format("%s\\capture%02d.jpeg", m_strCapPicPath, m_npic_jpeg);
		else
			sFilePath.Format("C:\\capture%02d.jpeg", m_npic_jpeg);

	}

	else
	{
		if( !NAME(PlayM4_GetBMP)(PORT, pImage, nBufSize, &pImageSize) )
		{
			return;
		}

		if(m_strCapPicPath.Compare(""))
			sFilePath.Format("%s\\capture%02d.bmp", m_strCapPicPath, m_npic_bmp);
		else
			sFilePath.Format("C:\\capture%02d.bmp", m_npic_bmp);
	}
	
	if(!clsFile.Open(sFilePath,CFile::modeCreate|CFile::modeWrite))
	{
		return;
	}
	try							
	{
		clsFile.Write(pImage, pImageSize);
		clsFile.Close();

		if(m_nCapPicType == 0)
			m_npic_bmp++;
		else
			m_npic_jpeg++;
	}
	
	catch (CFileException* e) 
	{
		e->ReportError();
		e->Delete();
	}
}

void CPlayerDlg::Cappic() 
{
	// TODO: Add your control notification handler code here
	PBYTE	pImage		= NULL;
	DWORD   nBufSize	= m_nWidth * m_nHeight * 5;  // 保证足够大即可(不会小于一幅bmp或者jpeg图像大小)

	try
	{
		pImage = new BYTE[nBufSize];
		if(NULL == pImage)
		{
			throw 0;
		}
		
		GetPic(pImage, nBufSize);
	}

	catch(...)
	{
	}

	if(pImage != NULL)
	{
		delete []pImage;
		pImage = NULL;
	}
}

// close or open sound
void CPlayerDlg::Sound() 
{
	// TODO: Add your control notification handler code here
	if(m_bSound)
	{
		if(NAME(PlayM4_StopSound)())
		{
			m_bSound = FALSE;
			m_ctrlBtnSound.SetIcon(IDI_SOUND_DISABLE);
		}
	}
	else
	{
		if(NAME(PlayM4_PlaySound)(PORT))
		{
			m_ctrlBtnSound.SetIcon(IDI_SOUND_ENABLE);
			m_bSound = TRUE;
		}
	}
}

// adjust sound
void  CPlayerDlg::AdjustSound(BOOL bFlag)
{
	int nSoundPos = m_SoundSlider.GetPos();	
	

	if(bFlag)
	{
#ifdef _WAVE_ADJ
		nSoundPos += (MAX_WAVE_COEF - MIN_WAVE_COEF)/0xf;
		nSoundPos = min(nSoundPos, MAX_WAVE_COEF);
#else
		nSoundPos += 0xffff/0xf;
		nSoundPos = min(nSoundPos, 0xffff-1);
#endif
	}

	else
	{
#ifdef _WAVE_ADJ
		nSoundPos -= (MAX_WAVE_COEF - MIN_WAVE_COEF)/0xf;
		nSoundPos = max(nSoundPos, MIN_WAVE_COEF);
#else
		nSoundPos -= 0xffff/0xf;
		nSoundPos = max(nSoundPos, 0);
#endif
	}

#ifdef _WAVE_ADJ
		NAME(PlayM4_AdjustWaveAudio)(PORT, nSoundPos);
#else
		NAME(PlayM4_SetVolume)(PORT, nSoundPos);
#endif

	m_SoundSlider.SetPos(nSoundPos);
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* button operation over
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/




/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* menu operation begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
// file operation:
void CPlayerDlg::Open() 
{
	Close();
	SetState();
	
	try
	{
		if(m_bStreamType)
			OpenStream();
		else
			OpenFile();

		NAME(PlayM4_SetPicQuality)(PORT, m_bPicQuality);
		NAME(PlayM4_SetDeflash)(PORT, m_bDeflash);

		m_bOpen = TRUE;

		NAME(PlayM4_GetPictureSize)(PORT, &m_nWidth, &m_nHeight);

		m_pDisplayRegion->SetResolution(m_nHeight, m_nWidth);
		//m_pMainMenu->ModifyMenu(IDM_SETDISPLAY, MF_BYCOMMAND, IDM_SETDISPLAY, "区域显示");
		// if video format is HCIF, then double the height
		if( (m_nWidth == WIDTH*2) && (m_nHeight <= HEIGHT_PAL) )
			m_nHeight *= 2;

		//InitWindowSize(m_nWidth, m_nHeight);
	}
	catch(...)
	{
		Close();
	}
}


void CPlayerDlg::Close() 
{
	// TODO: Add your command handler code here
	if(m_bOpen)
	{
		if(m_bStreamType)
			CloseStream();
		else
			CloseFile();	
	}
}

void CPlayerDlg::CutFile() 
{
	// TODO: Add your command handler code here
	CCutFile cutDlg;
	if(cutDlg.SetFileName(m_strPlayFileName))
		cutDlg.DoModal();

}

// view operation:
void CPlayerDlg::ViewFullScreen() 
{
	// TODO: Add your command handler code here
	m_bFullScreen = !m_bFullScreen;
	
	if(m_bFullScreen)
	{
		//Save the pre info;
		GetWindowPlacement(&m_OldWndpl);
		//Remove WS_SIZEBOX windows style. or not the window can't be full-creen.
		ModifyStyle(WS_SIZEBOX, 0, 0);
		
		CRect WindowRect, ClientRect;
		RECT  m_FullScreenRect;
		//ReDraw the window. Get the correct edge value.
//		GetWindowRect(&WindowRect);
//		WindowRect.left  += 1;
//		WindowRect.right += 1;
//		MoveWindow(CRect(0, 0, 352, 288), TRUE);
		
		GetWindowRect(&WindowRect);
		GetClientRect(&ClientRect);
		ClientToScreen(&ClientRect);
		
		//get the dest window rect.
		m_FullScreenRect.left   = WindowRect.left   - ClientRect.left + m_rcScreen.left;
		m_FullScreenRect.top    = WindowRect.top    - ClientRect.top  + m_rcScreen.top;
		m_FullScreenRect.right  = WindowRect.right  - ClientRect.right + m_rcScreen.right;
		m_FullScreenRect.bottom = WindowRect.bottom - ClientRect.bottom + m_rcScreen.bottom;
		//Move the main window to the dest rect.
		WINDOWPLACEMENT wndpl;
		wndpl.length  = sizeof(WINDOWPLACEMENT);
		wndpl.flags   = 0;
		wndpl.showCmd = SW_SHOWNORMAL;
		wndpl.rcNormalPosition = m_FullScreenRect;
		SetWindowPlacement(&wndpl);
		//Move the view winow to full-screen.
		RECT rc;
		GetClientRect(&rc);
		m_ctrlVideoPic.MoveWindow(&rc,TRUE);
	
		//Remove WS_VISIBLE window style.
		m_ctrlBtnPlay.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnPause.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnStop.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnFast.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnGEnd.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnSlow.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnGStart.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlStepBackward.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlStepForward.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnCapPic.ModifyStyle(WS_VISIBLE, 0, 0);
		m_ctrlBtnSound.ModifyStyle(WS_VISIBLE, 0, 0);

		GetDlgItem(IDC_INTER1)->ModifyStyle(WS_VISIBLE, 0, 0);
		GetDlgItem(IDC_INTER2)->ModifyStyle(WS_VISIBLE, 0, 0);
		GetDlgItem(IDC_INTER3)->ModifyStyle(WS_VISIBLE, 0, 0);

		m_SoundSlider.ModifyStyle(WS_VISIBLE,0,0);
		m_PlaySlider.ModifyStyle(WS_VISIBLE,0,0);

		m_ctrlPlayText.ModifyStyle(WS_VISIBLE,0,0);

	}
	else
	{
		//Visible the control.
		m_ctrlBtnPlay.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnPause.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnStop.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnFast.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnGEnd.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnSlow.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnGStart.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlStepForward.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlStepBackward.ModifyStyle(0, WS_VISIBLE, 0);
		m_ctrlBtnCapPic.ModifyStyle(0, WS_VISIBLE, 0);			
		m_ctrlBtnSound.ModifyStyle(0, WS_VISIBLE, 0);

		GetDlgItem(IDC_INTER1)->ModifyStyle(0, WS_VISIBLE, 0);
		GetDlgItem(IDC_INTER2)->ModifyStyle(0, WS_VISIBLE, 0);
		GetDlgItem(IDC_INTER3)->ModifyStyle(0, WS_VISIBLE, 0);

		m_PlaySlider.ModifyStyle(0,WS_VISIBLE,0);
		m_SoundSlider.ModifyStyle(0,WS_VISIBLE,0);

		m_ctrlPlayText.ModifyStyle(0,WS_VISIBLE,0);
		
		//make the window can be resize.
		ModifyStyle(0, WS_SIZEBOX, 0);
		//change the window pos to pre rect.
		SetWindowPlacement(&m_OldWndpl);

	}
	this->RedrawWindow();

	NAME(PlayM4_RefreshPlay)(PORT);
}

void CPlayerDlg::ViewZoom(UINT nID)
{
	if(m_bFullScreen)
	{
		//ViewFullScreen();
	}

	//for(int i = 0; i < 3; i++)
	{
		//m_pMainMenu->CheckMenuItem(IDM_VIEW_ZOOM_50 + i, MF_UNCHECKED);
	}

	int nItem = nID - IDM_VIEW_ZOOM_100;

	switch(nItem)
	{
	case 0:
		//InitWindowSize(m_nWidth, m_nHeight);
		break;
	case -1:
		//InitWindowSize(m_nWidth >> 1, m_nHeight >> 1);
		break;
	case 1:
		//InitWindowSize(m_nWidth << 1, m_nHeight << 1);
		break;
	default:
		break;
	}
	//m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);
}

void CPlayerDlg::Infomation() 
{
	// TODO: Add your command handler code here

	CInfo infoDlg;
	infoDlg.DoModal();
}

void CPlayerDlg::SetDisplay() 
{
	// TODO: Add your command handler code here

	RECT RectP;
	RECT RectS;

	if (!m_pDisplayRegion->m_bValid) {	
		if(m_enumState == State_Play)
		{
			NAME(PlayM4_Pause)(PORT, TRUE);
			m_enumState = State_Pause;
			SetState();
		}
		
//		m_ctrlBtnCapPic.EnableWindow(FALSE);
//		m_ctrlBtnSound.EnableWindow(FALSE);	
//		m_ctrlBtnSlow.EnableWindow(FALSE);
//		m_ctrlBtnFast.EnableWindow(FALSE);
//		m_ctrlBtnGStart.EnableWindow(FALSE);
//		m_ctrlBtnGEnd.EnableWindow(FALSE);
//		m_ctrlBtnStop.EnableWindow(FALSE);
//		m_ctrlBtnPlay.EnableWindow(FALSE);
//		m_ctrlBtnPause.EnableWindow(FALSE);	
//		m_ctrlStepBackward.EnableWindow(FALSE);
//		m_ctrlStepForward.EnableWindow(FALSE);
// 		m_pMainMenu->EnableMenuItem(2, MF_GRAYED|MF_BYPOSITION|MF_DISABLED);
		//m_pMainMenu->ModifyMenu(IDM_SETDISPLAY, MF_BYCOMMAND, IDM_SETDISPLAY, "取消区域显示");
		
		m_pDisplayRegion->Create(IDD_RANGE);
		GetWindowRect(&RectP);
		
		m_pDisplayRegion->GetWindowRect(&RectS);
		
		RectS.right = RectS.right - RectS.left + RectP.right;
		RectS.left = RectP.right;
		RectS.bottom = RectS.bottom - RectS.top + RectP.top;
		RectS.top = RectP.top; 
		if (RectP.right + 10 > (int)m_dwScreenWidth) {
			RectS.left = RectP.left - (RectS.right - RectS.left);
			RectS.right = RectP.left;
		}
		m_pDisplayRegion->MoveWindow(&RectS);
		
		
		m_pDisplayRegion->InitShow();
		ThrowB(IDM_THROW0);          // when step forward one by one, don't throw B frame;
		NAME(PlayM4_OneByOne)(PORT);
		
		Sleep(50);
		m_pDisplayRegion->DrawRectangle();
	}
	else
	{
//		m_ctrlBtnCapPic.EnableWindow(TRUE);
//		m_ctrlBtnSound.EnableWindow(TRUE);	
//		m_ctrlBtnSlow.EnableWindow(TRUE);
//		m_ctrlBtnFast.EnableWindow(TRUE);
//		m_ctrlBtnGStart.EnableWindow(TRUE);
//		m_ctrlBtnGEnd.EnableWindow(TRUE);
//		m_ctrlBtnStop.EnableWindow(TRUE);
//		m_ctrlBtnPlay.EnableWindow(TRUE);
//		m_ctrlBtnPause.EnableWindow(TRUE);	
//		m_ctrlStepBackward.EnableWindow(TRUE);
//		m_ctrlStepForward.EnableWindow(TRUE);
// 		m_pMainMenu->EnableMenuItem(2, MF_ENABLED|MF_BYPOSITION);
		//m_pMainMenu->ModifyMenu(IDM_SETDISPLAY, MF_BYCOMMAND, IDM_SETDISPLAY, "区域显示"); 
		Play();
		SetState();
		m_pDisplayRegion->DestroyWindow();
	}
}

BOOL CPlayerDlg::SetDevice(UINT nID)
{
	BOOL bFunctionOK = FALSE;

#if (WINVER > 0x0400)
	DWORD nVal = NAME(PlayM4_GetDDrawDeviceTotalNums)();
	if(nVal >= 1)
	{
		UINT nDeviceSeq = nID - IDM_DEVICE0;
		//for(int i = 0; i < MAX_DISPLAY_DEVICE; i++)
		{
			//m_pMainMenu->CheckMenuItem(IDM_DEVICE0 + i, MF_UNCHECKED);
		}

		if(NAME(PlayM4_SetDDrawDevice)(PORT, nDeviceSeq + 1))
		{
			bFunctionOK = TRUE;
		}

		//m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);
	}
#endif
	return bFunctionOK;
}

// control operation:
void CPlayerDlg::VideoControl()
{
	// TODO: Add your command handler code here

	m_pVideoControl->Create(IDD_VIDEOCTRL);
	m_pVideoControl->ShowWindow(SW_SHOW);
	//m_pMainMenu->EnableMenuItem(IDM_VIDEO_CONTROL, MF_GRAYED | MF_DISABLED);
}

void CPlayerDlg::Repeat() 
{
	// TODO: Add your command handler code here

	m_bRepeatPlay = !m_bRepeatPlay;
	UINT nFlag = m_bRepeatPlay ? MF_CHECKED : MF_UNCHECKED;
	//m_pMainMenu->CheckMenuItem(IDM_REPEAT, nFlag);
}

void CPlayerDlg::Locate() 
{
	// TODO: Add your command handler code here

	m_pSeek->Create(IDD_SEEK);
	//m_pMainMenu->EnableMenuItem(IDM_SEEK,MF_GRAYED | MF_DISABLED);
}

// option operation:
void CPlayerDlg::StreamType() 
{
	// TODO: Add your command handler code here

	m_bStreamType = !m_bStreamType;
	UINT nFlag = m_bStreamType ? MF_CHECKED : MF_UNCHECKED;
	//m_pMainMenu->CheckMenuItem(IDM_STREAM_TYPE, nFlag);
}

void CPlayerDlg::Deflash() 
{
	// TODO: Add your command handler code here

	m_bDeflash = !m_bDeflash;
	UINT nFlag = m_bDeflash ? MF_CHECKED : MF_UNCHECKED;
	//m_pMainMenu->CheckMenuItem(IDM_DEFLASH, nFlag);

	NAME(PlayM4_SetDeflash)(PORT, m_bDeflash);
}

void CPlayerDlg::Quality() 
{
	// TODO: Add your command handler code here

	m_bPicQuality = !m_bPicQuality;
	UINT nFlag = m_bPicQuality ? MF_CHECKED : MF_UNCHECKED;
	//m_pMainMenu->CheckMenuItem(IDM_QUALITY, nFlag);

	NAME(PlayM4_SetPicQuality)(PORT, m_bPicQuality);
}

void CPlayerDlg::ThrowB(UINT nID)
{
	NAME(PlayM4_ThrowBFrameNum)(PORT, nID - IDM_THROW0);

	//for(int i = IDM_THROW0; i <= IDM_THROW2; i++ )
	//	m_pMainMenu->CheckMenuItem(i, MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);
}

void CPlayerDlg::DisplayType(UINT nID)
{
	//m_pMainMenu->CheckMenuItem(IDM_DISNORMAL,  MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(IDM_DISQUARTER, MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);

	if(nID == IDM_DISNORMAL)
		NAME(PlayM4_SetDisplayType)(PORT, DISPLAY_NORMAL);
	else
		NAME(PlayM4_SetDisplayType)(PORT, DISPLAY_QUARTER);
}

void CPlayerDlg::SelectTimer(UINT nID)
{
	//m_pMainMenu->CheckMenuItem(IDM_TIMER1, MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(IDM_TIMER2, MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);

	if(nID == IDM_TIMER1)
		NAME(PlayM4_SetTimerType)(PORT, TIMER_1, 0);
	else
		NAME(PlayM4_SetTimerType)(PORT, TIMER_2, 0);
}

void CPlayerDlg::ResetBuf() 
{
	// TODO: Add your command handler code here
	// Only test the interface. 
	NAME(PlayM4_ResetBuffer)(PORT, BUF_VIDEO_RENDER);
	NAME(PlayM4_ResetBuffer)(PORT, BUF_AUDIO_RENDER);
	NAME(PlayM4_ResetBuffer)(PORT, BUF_VIDEO_SRC);
	NAME(PlayM4_ResetBuffer)(PORT, BUF_AUDIO_SRC);
}

void CPlayerDlg::CapPicType(UINT nID)
{
	//m_pMainMenu->CheckMenuItem(IDM_CAP_BMP,  MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(IDM_CAP_JPEG, MF_UNCHECKED);
	//m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);

	if(nID == IDM_CAP_BMP)
		m_nCapPicType = 0;
	else
		m_nCapPicType = 1;
}

void CPlayerDlg::CappicPath() 
{
	char	     szDir[MAX_PATH];
	BROWSEINFO   bi;
	ITEMIDLIST  *pidl;

	bi.hwndOwner	  = this->m_hWnd;
	bi.pidlRoot		  = NULL;
	bi.pszDisplayName = szDir;
	bi.lpszTitle	  = "请选择目录";
	bi.ulFlags		  = BIF_RETURNONLYFSDIRS;
	bi.lpfn			  = NULL;
	bi.lParam		  = 0;
	bi.iImage		  = 0;

	pidl = SHBrowseForFolder(&bi);
	if(NULL == pidl) 
		return;

	if(!SHGetPathFromIDList(pidl, szDir)) 
		return;

	m_strCapPicPath.Format("%s",szDir);
}

void CPlayerDlg::ConvertToAVI() 
{
	// TODO: Add your command handler code here	
	int ReturnValue;
	CString str, m_csInfo;

	str.Format("Convert  to AVI File will be Failed to Play the MPEG4 File\n\n");
	m_csInfo += str;
	str.Format("The Converted AVI File can't be Larger than 2G!\n\n");
	m_csInfo += str;
	str.Format("Playing the Converted AVI File must Install the Divx!\n\n");
	m_csInfo += str;
	str.Format("if Continued,Click OK Button!\n");
    m_csInfo += str;
	ReturnValue = MessageBox((LPCTSTR)m_csInfo, NULL, MB_YESNO); 
	

	if(ReturnValue == IDYES)
	{
		Close();

		m_bConvertAVI = TRUE;
		str.Format("AVI Movie Files (*.avi)|*.avi||");
	   
		CFileDialog Filedlg(FALSE, "*.avi", "*.avi", OFN_LONGNAMES|OFN_CREATEPROMPT|OFN_OVERWRITEPROMPT, str, this);
	   
		if(Filedlg.DoModal() == IDOK)
		{
			m_strSaveAVIPath = Filedlg.GetPathName();
		  
		    if(BrowseFile(&m_strPlayFileName))
			{
				Open();
			
				if(m_bConvertAVI)
					SetAVIState();
				else
					SetState();
				SortControl();
			}
			else
			{
				m_bConvertAVI = FALSE;
				SetState();
			}
		}
		else
		{
			m_bConvertAVI = FALSE;
			SetState();
		}
	}
}

void CPlayerDlg::AppAbout() 
{
	// TODO: Add your command handler code here
	
}

void CPlayerDlg::AppHelp()
{
	CHelpDlg HelpDlg;
	HelpDlg.DoModal();
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* menu operation over
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/



/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* when you click the menu item, you come here
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
void CPlayerDlg::OnMenuItem(UINT nID)
{
	switch(nID)
	{
	case IDM_FILE_OPEN:
		if(BrowseFile(&m_strPlayFileName))
		{
			Open();
			SetState();
		}
		break;
		
	case IDM_FILE_CLOSE:
		Close();
		SetState();
		break;
	
	case IDM_CUT_FILE:
		CutFile();
		break;

	case IDM_APP_EXIT:
		SendMessage(WM_CLOSE);
		break;

	case IDM_VIEW_FULLSCREEN:
		//ViewFullScreen();
		break;

	case IDM_VIEW_ZOOM_50:
	case IDM_VIEW_ZOOM_100:
	case IDM_VIEW_ZOOM_200:
		ViewZoom(nID);
		break;
	
	case IDM_INFO:
		Infomation();
		break;
	
	case IDM_SETDISPLAY:
		SetDisplay();
		break;
	
	case IDM_DEVICE0:
	case IDM_DEVICE1:
	case IDM_DEVICE2:
	case IDM_DEVICE3:
		SetDevice(nID);
		break;

	case IDM_PLAY_PAUSE:
		if(m_enumState == State_Play)
		{
			Pause();
			SetState();
		}
		else if(m_enumState == State_Pause || m_enumState == State_Stop)
		{
			Play();
			SetState();
		}
		break;

	case IDM_STOP:
		if(m_enumState != State_Close)
		{
			Stop();
			SetState();
		}
		break;

	case IDM_STEPFORWARD:
		if(m_enumState != State_Stop)
		{
			StepForward();
			SetState();
		}
		break;
		
	case IDM_STEPBACKWARD:
		if(m_enumState != State_Stop)
		{
			StepBackward();
			SetState();
		}
		break;

	case IDM_GOTOSTART:
		GotoStart();
		break;

	case IDM_GOTOEND:
		GotoEnd();
		break;

	case IDM_SEEK:
		Locate();
		break;

	case IDM_VIDEO_CONTROL:
		VideoControl();
		break;

	case IDM_REPEAT:
		Repeat();
		break;
	
	case IDM_STREAM_TYPE:
		StreamType();
		break;
	
	case IDM_DEFLASH:
		Deflash();
		break;
		
	case IDM_QUALITY:
		Quality();
		break;
	
	case IDM_PREVIEW50:
		break;
		
	case IDM_SHARPEN_NONE:
	case IDM_SHARPEN_LEVEL1:
	case IDM_SHARPEN_LEVEL2:
	case IDM_SHARPEN_LEVEL3:
	case IDM_SHARPEN_LEVEL4:
	case IDM_SHARPEN_LEVEL5:
	case IDM_SHARPEN_LEVEL6:
		break;

	case IDM_THROW0:
	case IDM_THROW1:                      
	case IDM_THROW2:
		ThrowB(nID);
		break;

	case IDM_DISNORMAL:                   
	case IDM_DISQUARTER:
		DisplayType(nID);
		break;

	case IDM_TIMER1:
	case IDM_TIMER2:
		SelectTimer(nID);
		break;

	case IDM_RESET_BUF:
		ResetBuf();
		break;

	case IDM_CAP_BMP:
	case IDM_CAP_JPEG:
		CapPicType(nID);
		break;

	case IDM_CAPPIC_PATH:
		CappicPath();
		break;

	case IDM_CONVERT:
		ConvertToAVI();
		break;
	
	case IDM_APP_HELP:
		AppHelp();
		break;
		
	case IDM_APP_ABOUT:
		AppAbout();
		break;

	default:
		break;
	}
}


/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* when you click the button item, you come here
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
void CPlayerDlg::OnButtonItem(UINT nID)
{
	switch(nID)
	{
	case IDC_PLAY:
		Play();
		break;

	case IDC_PAUSE:
		Pause();
		break;

	case IDC_STOP:
		Stop();
		break;

	case IDC_GOTOSTART:
		GotoStart();
		break;

	case IDC_SLOW:
		Play();
		Slow();
		break;

	case IDC_FAST:
		Play();
		Fast();
		break;

	case IDC_GOTOEND:
		GotoEnd();
		break;

	case IDC_STEP:
		StepForward();
		break;
		
	case IDC_STEPBACK:
		StepBackward();
		break;
		
	case IDC_CAPPIC:
		Cappic();
		break;
		
	case IDC_SOUND:
		Sound();
		break;
	
	default:
		break;
	}

	SetState();
}
//void CPlayerDlg::OnBnClickedButton1() 
//{
//	m_strPlayFileName = "D:\\stream3_0.264";
//	Open();
//	SetState();
//}

void CPlayerDlg::OnBnClickedBtnQuery()
{
	DWORD returnValue;

	CTime timeB,timeE;
	m_timeBegin.GetTime( timeB );
	m_timeEnd.GetTime( timeE );

	CString sSt,sEt,sSd,sEd;
	sSd.Format("%d%02d%02d",timeB.GetYear(),timeB.GetMonth(),timeB.GetDay());
	sSt.Format(_T("%02d%02d%02d"),timeB.GetHour(),timeB.GetMinute(),timeB.GetSecond());//0,0,0);//
	sEd.Format("%d%02d%02d",timeE.GetYear(),timeE.GetMonth(),timeE.GetDay()); 
	sEt.Format(_T("%02d%02d%02d"),timeE.GetHour(),timeE.GetMinute(),timeE.GetSecond());//23,59,59);//

	double dBegin=0.0,dEnd=0.0,dNow=0.0,dTemp=0.0;
	dBegin = atof( sSd+sSt );
	dEnd = atof( sEd+sEt );

	if( dBegin > dEnd )
	{
		MessageBox( "时间输入有误！");
		return;
	}
	m_List_Vedio.DeleteAllItems();
	g_strAllVideoFile.RemoveAll();

	//CStringArray sArrayTemp;

	CString sPath,str;
	if( SetCurrentDirectory(g_strVideoPath) == TRUE)
	{
		CFileFind finder;
		BOOL bWorking = finder.FindFile("*.264");
		while (bWorking)
		{
			bWorking = finder.FindNextFile();//1_2010-10-17-101010.264
			sPath = finder.GetFileName();
			g_strAllVideoFile.Add( sPath );

			str = sPath.Mid( 2,17 );
			str.Delete(10);
			str.Delete(7);
			str.Delete(4);
			dNow = atof(str);
			if( dNow>=dBegin && dNow<=dEnd )
			{
				m_List_Vedio.InsertItem( 0,sPath );
			}
		}

		CString str1,str2,s1,s2,sTemp;
		for( int i=0;i<g_strAllVideoFile.GetCount();i++ )
		{
			str1 = g_strAllVideoFile[i];
			s1 = str1.Mid( 2,17 );
			s1.Delete(10);
			s1.Delete(7);
			s1.Delete(4);
			dBegin = atof(s1);
			for( int j=i+1;j<g_strAllVideoFile.GetCount();j++ )
			{
				str2 = g_strAllVideoFile[j];
				s2 = str2.Mid( 2,17 );
				s2.Delete(10);
				s2.Delete(7);
				s2.Delete(4);
				dEnd = atof(s2);
				
				if( dEnd<dBegin )
				{
					dTemp = dBegin;
					dBegin = dEnd;
					dEnd = dTemp;
					sTemp = str1;
					str1 = str2;
					str2 = sTemp;
					g_strAllVideoFile[i] = str1;
					g_strAllVideoFile[j] = str2;
				}
			}
		}
	}
	else
	{
		returnValue = GetLastError();
	}
}

void CPlayerDlg::OnNMDblclkListVedio(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO: 在此添加控件通知处理程序代码
	int iListCount = m_List_Vedio.GetItemCount();
	POSITION pos = m_List_Vedio.GetFirstSelectedItemPosition();
	int nListSel = m_List_Vedio.GetNextSelectedItem(pos);
	if(nListSel>=iListCount || nListSel==-1)
	{
		return;
	}
	////////////////////////////////////////////////
	CString str;
	str = m_List_Vedio.GetItemText( nListSel,0 );

	m_strPlayFileName = str;
	Open();
	SetState();

	*pResult = 0;
}
void CPlayerDlg::Init()
{
	if( m_bInit ) return;

	m_bInit = true;

	m_dwScreenWidth  = GetSystemMetrics(SM_CXSCREEN);
	m_dwScreenHeight = GetSystemMetrics(SM_CYSCREEN);

	m_rcScreen.left  = 0;
	m_rcScreen.right = m_dwScreenWidth;
	m_rcScreen.top   = 0;
	m_rcScreen.bottom= m_dwScreenHeight;


	// Init Play Slider
	VERIFY(m_PlaySlider.CreateFromStatic(
		   SBS_HORZ|WS_CHILD|SS_LEFT|SS_NOTIFY|WS_VISIBLE,
		   this, IDC_PLAY_RECT_SLIDER, IDC_PLAY_SLIDER));

	m_PlaySlider.SetScrollRange(0, PLAYER_SLIDER_MAX);
	m_PlaySlider.EnableThumbColor(FALSE);
	m_PlaySlider.EnableThumbGripper(TRUE);
	m_PlaySlider.EnableChannelColor(FALSE);

	// Init Sound Slider
#ifdef _WAVE_ADJ
	m_SoundSlider.SetRangeMin(MIN_WAVE_COEF);
	m_SoundSlider.SetRangeMax(MAX_WAVE_COEF);
#else
	m_SoundSlider.SetRangeMin(0);
	m_SoundSlider.SetRangeMax(0xffff-1);
#endif

	m_SoundSlider.SetLineSize(1);
	m_SoundSlider.SetPageSize(5);

	NAME(PlayM4_SetVolume)(PORT,m_SoundSlider.GetPos());

	// Init the parameters
	m_StartPoint.x		 =	0;
	m_StartPoint.y		 =	0;
	m_dwTotalFrames		 =	0;
	m_dwMaxFileTime		 =	0;
	m_dwDisplayHour		 =	0;
	m_dwDisplayMinute	 =	0;
	m_dwDisplaySecond	 =	0;
	m_nPrePlayPos		 =  0;
	m_dwOldDeviceNum     =  0;

	m_npic_bmp			 =	0;
	m_npic_jpeg			 =	0;
	m_nCapPicType		 =	0;
	m_strCapPicPath		 =  _T("");

	m_bStartDraw         =	FALSE;
	m_bSound			 =	FALSE;
	m_bOpen			     =	FALSE;
	m_bFullScreen		 =	FALSE;
	m_bRepeatPlay		 =	FALSE;
	m_bStreamType		 =	FALSE;
	m_bConvertAVI		 =  FALSE;
	m_bPicQuality	     =  TRUE;
	m_bDeflash			 =  TRUE;
#ifdef _HIGH_FRUID
	m_bHighFluid		 =  TRUE;
#else
	m_bHighFluid		 =  FALSE;
#endif

	m_bFileRefCreated	 =  FALSE;

	m_strPlayStateText	 =	_T("准备就绪");
	m_ctrlPlayText.ShowText(m_strPlayStateText);

	m_strSaveAVIPath	 =  _T("");

	// Init state text control
	m_ctrlPlayText.SetTextColor(RGB(255,255,255), FALSE);
	m_ctrlPlayText.SetBackgroundColor(RGB(0,0,0), FALSE);
	m_ctrlPlayText.SetBold(TRUE, FALSE);

	// init the sub dialogs
	m_pSeek				 =	new CSeek(this);
	m_pDisplayRegion	 =	new CDisplayRect(this);
	m_pVideoControl		 =  new CVideoCtrlDlg(this);

	// bitmap
	m_BlackBmp.LoadBitmap(IDB_BLACK);
	m_OverlayBmp.LoadBitmap(IDB_OVERLAY);
#ifdef _FOR_HIKPLAYM4_DLL_
	m_HikvisionBmp.LoadBitmap(IDB_HIKVISION);
	SetWindowText("HIKVISION 播放器");
	
	//m_HikvisionBmp.CreateBitmap( 500,488,1,8,NULL );
	// DWORD dwCount;

	//BITMAP bm;     
 //   m_HikvisionBmp.GetObject(sizeof(bm),&bm);
 //   dwCount = bm.bmWidthBytes * bm.bmHeight; //得到buf大小 


#else
	m_HikvisionBmp.LoadBitmap(IDB_BLACK);
	SetWindowText("播放器");
#endif

	// init state
	m_enumState = State_Close;
	SetState();

	// set the capture picture call back function;
	NAME(PlayM4_SetDisplayCallBack)(PORT, DisplayCBFun);
	// set the wave audio call back funtion;
	NAME(PlayM4_SetAudioCallBack)(PORT, WaveCBFun, (long)this);

#if (WINVER > 0x0400)
	// If do not support multi monitor,may not call!
	HMONITOR hMonitor;
	char chDriverDesp[50];
	char chDriverName[50];

	NAME(PlayM4_InitDDrawDevice)();
	DWORD nVal=NAME(PlayM4_GetDDrawDeviceTotalNums)();
	if(nVal >= 1)
	{
		nVal = min(nVal, MAX_DISPLAY_DEVICE);
		for(DWORD nCount = 1; nCount <= nVal; nCount ++) 
		{
			ZeroMemory(chDriverDesp, 50);
			NAME(PlayM4_GetDDrawDeviceInfo)(nCount, chDriverDesp, 50, chDriverName, 50, &hMonitor);
			//m_pMainMenu->GetSubMenu(1)->InsertMenu(IDM_TEMP_DEVICE, MF_BYCOMMAND, IDM_DEVICE0 + nCount - 1, chDriverDesp);
		}
	}
	
	else
	{
		ZeroMemory(chDriverDesp, 50);
		NAME(PlayM4_GetDDrawDeviceInfo)(0, chDriverDesp, 50, chDriverName, 50, &hMonitor);
		//m_pMainMenu->GetSubMenu(1)->InsertMenu(IDM_TEMP_DEVICE, MF_BYCOMMAND, IDM_DEVICE0, chDriverDesp);
	}

	//m_pMainMenu->GetSubMenu(1)->RemoveMenu(IDM_TEMP_DEVICE, MF_BYCOMMAND);
	//m_pMainMenu->CheckMenuItem(IDM_DEVICE0, MF_CHECKED);
	
	NAME(PlayM4_SetDDrawDevice)(PORT, 0);
#endif

	// Test adapter Capability;
	TestCapability(0);
	NAME(PlayM4_SetFileEndMsg)(PORT, m_hWnd, WM_FILE_END);
	NAME(PlayM4_SetEncChangeMsg)(PORT, m_hWnd, WM_ENC_CHANGE);
	
	// used for command line
	if(m_strPlayFileName.Compare(""))
	{
		Open();
		SetState();
	}

	UpdateData(FALSE);
	SortControl();
}