分享一下海康威视古老的播放器源码

一切高深的技术&＃xff0c;翻开源码顿悟&＃xff1a;

这是海康威视SDK附带的MFC Demo&＃xff0c;年头有些久了&＃xff0c;不过参考价值还是很大的&＃xff1a;

ReportError();e->Delete();}
}void CPlayerDlg::Cappic()
{// TODO: Add your control notification handler code herePBYTE pImage &＃61; NULL;DWORD nBufSize &＃61; m_nWidth * m_nHeight * 5; // 保证足够大即可(不会小于一幅bmp或者jpeg图像大小)try{pImage &＃61; new BYTE[nBufSize];if(NULL &＃61;&＃61; pImage){throw 0;}GetPic(pImage, nBufSize);}catch(...){}if(pImage !&＃61; NULL){delete []pImage;pImage &＃61; NULL;}
}// close or open sound
void CPlayerDlg::Sound()
{// TODO: Add your control notification handler code hereif(m_bSound){if(NAME(PlayM4_StopSound)()){m_bSound &＃61; FALSE;m_ctrlBtnSound.SetIcon(IDI_SOUND_DISABLE);}}else{if(NAME(PlayM4_PlaySound)(m_lPort)){m_ctrlBtnSound.SetIcon(IDI_SOUND_ENABLE);m_bSound &＃61; TRUE;}}
}// adjust sound
void CPlayerDlg::AdjustSound(BOOL bFlag)
{int nSoundPos &＃61; m_SoundSlider.GetPos(); if(bFlag){
#ifdef _WAVE_ADJnSoundPos &＃43;&＃61; (MAX_WAVE_COEF - MIN_WAVE_COEF)/0xf;nSoundPos &＃61; min(nSoundPos, MAX_WAVE_COEF);
#elsenSoundPos &＃43;&＃61; 0xffff/0xf;nSoundPos &＃61; min(nSoundPos, 0xffff-1);
#endif}else{
#ifdef _WAVE_ADJnSoundPos -&＃61; (MAX_WAVE_COEF - MIN_WAVE_COEF)/0xf;nSoundPos &＃61; max(nSoundPos, MIN_WAVE_COEF);
#elsenSoundPos -&＃61; 0xffff/0xf;nSoundPos &＃61; max(nSoundPos, 0);
#endif}#ifdef _WAVE_ADJNAME(PlayM4_AdjustWaveAudio)(m_lPort, nSoundPos);
#elseNAME(PlayM4_SetVolume)(m_lPort, WORD(nSoundPos));
#endifm_SoundSlider.SetPos(nSoundPos);
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* button operation over
/*************************************************************************/
/*************************************************************************/
/*************************************************************************//*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* menu operation begin
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
// file operation:
void CPlayerDlg::Open()
{Close();SetState();if (m_lPort &＃61;&＃61; -1){PlayM4_GetPort(&m_lPort);}try{NAME(PlayM4_SetEncChangeMsg)(m_lPort, m_hWnd, WM_ENC_CHANGE);NAME(PlayM4_SetEncTypeChangeCallBack(m_lPort, EncChange, (long)this));if(m_bStreamType){OpenStream();}else{OpenFile();}NAME(PlayM4_SetPicQuality)(m_lPort, m_bPicQuality);NAME(PlayM4_SetDeflash)(m_lPort, m_bDeflash);
// NAME(PlayM4_SetPlayMode)(m_lPort, m_bHighFluid);m_bOpen &＃61; TRUE;NAME(PlayM4_GetPictureSize)(m_lPort, &m_nWidth, &m_nHeight);NAME(PlayM4_SetVolume)(m_lPort,WORD(m_SoundSlider.GetPos()));m_pDisplayRegion->SetResolution(m_nHeight, m_nWidth);m_pMainMenu->ModifyMenu(IDM_SETDISPLAY, MF_BYCOMMAND, IDM_SETDISPLAY, "Multi Display");// if video format is HCIF, then double the heightif( (m_nWidth &＃61;&＃61; WIDTH*2) && (m_nHeight <&＃61; HEIGHT_PAL) ){m_nHeight *&＃61; 2;}InitWindowSize(m_nWidth, m_nHeight);}catch(...){Close();}
}void CPlayerDlg::Close()
{// TODO: Add your command handler code hereif(m_bOpen){if(m_bStreamType){CloseStream();}else{CloseFile(); }if(m_pWatermarkDlg){m_pWatermarkDlg->DestroyWindow();}m_nWidth &＃61; 352;m_nHeight &＃61; 288;// m_HikvisionBmp.LoadBitmap(IDB_HIKVISION);
// m_ctrlVideoPic.SetBitmap(m_HikvisionBmp);
// m_ctrlVideoPic.ShowWindow(SW_SHOW);SetWindowText("Player");m_ctrlVideoPic.Invalidate();}
}void CPlayerDlg::CutFile()
{// TODO: Add your command handler code hereCCutFile cutDlg;if(cutDlg.SetFileName(m_strPlayFileName)){cutDlg.DoModal();}
}void CPlayerDlg::SetSecretKey()
{CSetKeyDlg keyDlg(m_lPort);keyDlg.DoModal();
}// view operation:
void CPlayerDlg::ViewFullScreen()
{// TODO: Add your command handler code herem_bFullScreen &＃61; !m_bFullScreen;if(m_bFullScreen){//Save the pre info;GetWindowPlacement(&m_OldWndpl);//Remove WS_SIZEBOX windows style. or not the window can&＃39;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 &＃43;&＃61; 1;
// WindowRect.right &＃43;&＃61; 1;
// MoveWindow(CRect(0, 0, 352, 288), TRUE);GetWindowRect(&WindowRect);GetClientRect(&ClientRect);ClientToScreen(&ClientRect);//get the dest window rect.m_FullScreenRect.left &＃61; WindowRect.left - ClientRect.left &＃43; m_rcScreen.left;m_FullScreenRect.top &＃61; WindowRect.top - ClientRect.top &＃43; m_rcScreen.top;m_FullScreenRect.right &＃61; WindowRect.right - ClientRect.right &＃43; m_rcScreen.right;m_FullScreenRect.bottom &＃61; WindowRect.bottom - ClientRect.bottom &＃43; m_rcScreen.bottom;//Move the main window to the dest rect.WINDOWPLACEMENT wndpl;wndpl.length &＃61; sizeof(WINDOWPLACEMENT);wndpl.flags &＃61; 0;wndpl.showCmd &＃61; SW_SHOWNORMAL;wndpl.rcNormalPosition &＃61; 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)(m_lPort);
}void CPlayerDlg::ViewZoom(UINT nID)
{if(m_bFullScreen){ViewFullScreen();}for(int i &＃61; 0; i <3; i&＃43;&＃43;){m_pMainMenu->CheckMenuItem(IDM_VIEW_ZOOM_50 &＃43; i, MF_UNCHECKED);}int nItem &＃61; 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 hereCInfo infoDlg;infoDlg.DoModal();
}void CPlayerDlg::SetDisplay()
{// TODO: Add your command handler code hereRECT RectP;RECT RectS;if (!m_pDisplayRegion->m_bValid) { if(m_enumState &＃61;&＃61; State_Play){NAME(PlayM4_Pause)(m_lPort, TRUE);m_enumState &＃61; 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, "Cancel Multi Display");m_pDisplayRegion->Create(IDD_RANGE);GetWindowRect(&RectP);m_pDisplayRegion->GetWindowRect(&RectS);RectS.right &＃61; RectS.right - RectS.left &＃43; RectP.right;RectS.left &＃61; RectP.right;RectS.bottom &＃61; RectS.bottom - RectS.top &＃43; RectP.top;RectS.top &＃61; RectP.top; if (RectP.right &＃43; 10 > (int)m_dwScreenWidth) {RectS.left &＃61; RectP.left - (RectS.right - RectS.left);RectS.right &＃61; RectP.left;}m_pDisplayRegion->MoveWindow(&RectS);m_pDisplayRegion->InitShow();ThrowB(IDM_THROW0); // when step forward one by one, don&＃39;t throw B frame;
// NAME(PlayM4_OneByOne)(m_lPort);
// m_enumState &＃61; State_Step;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, "Multi Display"); Play();SetState();m_pDisplayRegion->DestroyWindow();}
}BOOL CPlayerDlg::SetDevice(UINT nID)
{BOOL bFunctionOK &＃61; FALSE;#if (WINVER > 0x0400)DWORD nVal &＃61; NAME(PlayM4_GetDDrawDeviceTotalNums)();if(nVal >&＃61; 1){UINT nDeviceSeq &＃61; nID - IDM_DEVICE0;for(int i &＃61; 0; i CheckMenuItem(IDM_DEVICE0 &＃43; i, MF_UNCHECKED);}if(NAME(PlayM4_SetDDrawDevice)(m_lPort, nDeviceSeq &＃43; 1)){bFunctionOK &＃61; TRUE;}NAME(PlayM4_SetDDrawDeviceEx)(m_lPort, 1, nDeviceSeq &＃43; 1);m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);}
#endifreturn bFunctionOK;
}// control operation:
void CPlayerDlg::VideoControl()
{// TODO: Add your command handler code herem_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 herem_bRepeatPlay &＃61; !m_bRepeatPlay;UINT nFlag &＃61; m_bRepeatPlay ? MF_CHECKED : MF_UNCHECKED;m_pMainMenu->CheckMenuItem(IDM_REPEAT, nFlag);
}void CPlayerDlg::Locate()
{// TODO: Add your command handler code herem_pSeek->Create(IDD_SEEK);m_pMainMenu->EnableMenuItem(IDM_SEEK,MF_GRAYED | MF_DISABLED);
}// option operation:
void CPlayerDlg::StreamType()
{// TODO: Add your command handler code herem_bStreamType &＃61; !m_bStreamType;UINT nFlag &＃61; m_bStreamType ? MF_CHECKED : MF_UNCHECKED;m_pMainMenu->CheckMenuItem(IDM_STREAM_TYPE, nFlag);
}void CPlayerDlg::Deflash()
{// TODO: Add your command handler code herem_bDeflash &＃61; !m_bDeflash;UINT nFlag &＃61; m_bDeflash ? MF_CHECKED : MF_UNCHECKED;m_pMainMenu->CheckMenuItem(IDM_DEFLASH, nFlag);NAME(PlayM4_SetDeflash)(m_lPort, m_bDeflash);
}void CPlayerDlg::Quality()
{// TODO: Add your command handler code herem_bPicQuality &＃61; !m_bPicQuality;UINT nFlag &＃61; m_bPicQuality ? MF_CHECKED : MF_UNCHECKED;m_pMainMenu->CheckMenuItem(IDM_QUALITY, nFlag);NAME(PlayM4_SetPicQuality)(m_lPort, m_bPicQuality);
}void CPlayerDlg::HighFluid()
{// TODO: Add your command handler code herem_bHighFluid &＃61; !m_bHighFluid;UINT nFlag &＃61; m_bHighFluid ? MF_CHECKED : MF_UNCHECKED;m_pMainMenu->CheckMenuItem(IDM_PREVIEW50, nFlag);NAME(PlayM4_SetPlayMode)(m_lPort, m_bHighFluid);
}void CPlayerDlg::ImageSharpenLevel(UINT nID)
{UINT nOldID &＃61; IDM_SHARPEN_NONE &＃43; m_dwImageSharpenLevel;m_dwImageSharpenLevel &＃61; nID - IDM_SHARPEN_NONE;NAME(PlayM4_SetImageSharpen)(m_lPort, m_dwImageSharpenLevel);m_pMainMenu->CheckMenuItem(nOldID, MF_UNCHECKED);m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);
}void CPlayerDlg::ThrowB(UINT nID)
{NAME(PlayM4_ThrowBFrameNum)(m_lPort, nID - IDM_THROW0);for(int i &＃61; IDM_THROW0; i <&＃61; IDM_THROW2; i&＃43;&＃43; ){m_pMainMenu->CheckMenuItem(i, MF_UNCHECKED);}m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);
}void CPlayerDlg::SetDecodeType(UINT nID)
{NAME(PlayM4_SetDecodeFrameType)(m_lPort, nID - IDM_DECODE_NORMAL);for(int i &＃61; IDM_DECODE_NORMAL; i <&＃61; IDM_DECODE_NONE; i&＃43;&＃43; ){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 &＃61;&＃61; IDM_DISNORMAL){NAME(PlayM4_SetDisplayType)(m_lPort, DISPLAY_NORMAL);}else{NAME(PlayM4_SetDisplayType)(m_lPort, DISPLAY_QUARTER);}
}void CPlayerDlg::SelectTimer(UINT nID)
{for (int i &＃61; IDM_TIMERNULL; i CheckMenuItem(i, MF_UNCHECKED);}m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);NAME(PlayM4_SetTimerType)(m_lPort, nID - IDM_TIMERNULL, 0);
}void CPlayerDlg::ResetBuf()
{// TODO: Add your command handler code here// Only test the interface. NAME(PlayM4_ResetBuffer)(m_lPort, BUF_VIDEO_RENDER);NAME(PlayM4_ResetBuffer)(m_lPort, BUF_AUDIO_RENDER);NAME(PlayM4_ResetBuffer)(m_lPort, BUF_VIDEO_SRC);NAME(PlayM4_ResetBuffer)(m_lPort, 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 &＃61;&＃61; IDM_CAP_BMP){m_nCapPicType &＃61; 0;}else{m_nCapPicType &＃61; 1;}
}void CPlayerDlg::CappicPath()
{char szDir[MAX_PATH];BROWSEINFO bi;ITEMIDLIST *pidl;bi.hwndOwner &＃61; this->m_hWnd;bi.pidlRoot &＃61; NULL;bi.pszDisplayName &＃61; szDir;bi.lpszTitle &＃61; "请选择目录";bi.ulFlags &＃61; BIF_RETURNONLYFSDIRS;bi.lpfn &＃61; NULL;bi.lParam &＃61; 0;bi.iImage &＃61; 0;pidl &＃61; SHBrowseForFolder(&bi);if(NULL &＃61;&＃61; 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 &＃43;&＃61; str;str.Format("The Converted AVI File can&＃39;t be Larger than 2G!\n\n");m_csInfo &＃43;&＃61; str;str.Format("Playing the Converted AVI File must Install the Divx!\n\n");m_csInfo &＃43;&＃61; str;str.Format("if Continued,Click OK Button!\n");m_csInfo &＃43;&＃61; str;ReturnValue &＃61; MessageBox((LPCTSTR)m_csInfo, NULL, MB_YESNO); if(ReturnValue &＃61;&＃61; IDYES){Close();m_bConvertAVI &＃61; TRUE;str.Format("AVI Movie Files (*.avi)|*.avi||");CFileDialog Filedlg(FALSE, "*.avi", "*.avi", OFN_LONGNAMES|OFN_CREATEPROMPT|OFN_OVERWRITEPROMPT, str, this);if(Filedlg.DoModal() &＃61;&＃61; IDOK){m_strSaveAVIPath &＃61; Filedlg.GetPathName();if(BrowseFile(&m_strPlayFileName)){Open();if(m_bConvertAVI){SetAVIState();}else{SetState();}SortControl();}else{m_bConvertAVI &＃61; FALSE;SetState();}}else{m_bConvertAVI &＃61; FALSE;SetState();}}
}void CPlayerDlg::AppAbout()
{// TODO: Add your command handler code hereCAboutDlg AboutDlg;AboutDlg.DoModal();}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_SET_KEY:SetSecretKey();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_WATERMARK:GetWatermark();break;case IDM_PLAY_PAUSE:if(m_enumState &＃61;&＃61; State_Play){Pause();SetState();}else if(m_enumState &＃61;&＃61; State_Pause || m_enumState &＃61;&＃61; State_Stop){Play();SetState();}break;case IDM_STOP:if(m_enumState !&＃61; State_Close){Stop();SetState();}break;case IDM_STEPFORWARD:if(m_enumState !&＃61; State_Stop){StepForward();SetState();}break;case IDM_STEPBACKWARD:if(m_enumState !&＃61; 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:HighFluid();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:ImageSharpenLevel(nID);break;case IDM_THROW0:case IDM_THROW1: case IDM_THROW2:ThrowB(nID);break;case IDM_DECODE_NORMAL:case IDM_DECODE_I:case IDM_DECODE_NONE:SetDecodeType(nID);break;case IDM_DISNORMAL: case IDM_DISQUARTER:DisplayType(nID);break;case IDM_TIMER1:case IDM_TIMER2:case IDM_TIMERNULL: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;case IDM_BYRATE:case IDM_BYTIME:SetDiplayMode(nID);default:break;}
}void CPlayerDlg::GetWatermark()
{// TODO: Add your command handler code here
// WaterMarkDlg dlg;
// dlg.DoModal();m_pWatermarkDlg->Create(IDD_WATERMARK);m_pMainMenu->EnableMenuItem(IDM_WATERMARK, MF_GRAYED);
}//错误信息
char* CPlayerDlg::MyErrorToString(DWORD error)
{switch(error){case 0:return "No error.\0";case 1:return "The parameter that user inputted is invalid.\0";case 2:return "The order of the function to be called is incorrect.\0";case 3:return "Failure when creating system multimedia clock.\0";case 4:return "Failure when decoding video data.\0";case 5:return "Failure when decoding audio data.\0";case 6:return "Failure when allocating memory.\0";case 7:return "File open failed when calling API Hik_PlayM4_OpenFile.\0";case 8:return "Failure when creating thread or event.\0";case 9:return "Failure when creating directdraw object.\0";case 10:return "Failure when creating off-screen surface.\0";case 11:return "The input source buffer has overflowed when calling API Hik_PlayM4_InputData.\0";case 12:return "Failure when creating audio device.\0";case 13:return "Failure when setting audio volume.\0";case 14:return "The function only supports playing a file.\0";case 15:return "The function only supports playing a stream.\0";case 16:return "Neither MMX nor SSE arithmetic is supported by system.\0";case 17:return "Unknown file header.\0";case 18:return "The version of video decoder and video encoder is not compatible.\0";case 19:return "Failure when initializing decoder.\0";case 20:return "The file data is unknown. No I-frame found.\0";case 21:return "Failure when initializing multimedia clock.\0";case 22:return "Failure when blitting overlay.\0";case 23:return "Failure when updating overlay or offscreen surface.\0";case 24:return "Open file error, streamtype is multi.\0";case 25:return "Openfile error, streamtype is video.\0";case 26:return "JPEG compression error when capturing jpeg file.\0";case 27:return "Version of this file not supported when extracting h264 video data.\0";case 28:return "Failure when extracting video data.\0";default:return "Unrecognized error value.\0";}
}/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* 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::OnDestroy()
{CDialog::OnDestroy();PlayM4_ReleaseDDrawDevice();// TODO: Add your message handler code hereif(m_pQcifTempBuf){delete []m_pQcifTempBuf;m_pQcifTempBuf &＃61; NULL;}
}LRESULT CPlayerDlg::WatermarkOk(WPARAM /*wParam*/, LPARAM /*lParam*/)
{m_pWatermarkDlg->DestroyWindow();if(m_enumState &＃61;&＃61; State_Pause || m_enumState &＃61;&＃61; State_Play){m_pMainMenu->EnableMenuItem(IDM_WATERMARK, MF_ENABLED);}return S_OK;
}BOOL CPlayerDlg::SetDiplayMode(int nID)
{
// for (int i &＃61; IDM_BYRATE; i // {
// m_pMainMenu->CheckMenuItem(i, MF_UNCHECKED);
// }
//
// m_pMainMenu->CheckMenuItem(nID, MF_CHECKED);
//
// return PlayM4_SetDisplayMode(m_lPort, nID - IDM_BYRATE);return FALSE;
}

我比较喜欢的是关于AVI的封装部分&＃xff1a;

#ifndef _AVIFMT_H_
#define _AVIFMT_H_//
//
//#ifndef DWORD
#define DWORD unsigned long
#endif#ifndef WORD
#define WORD unsigned short
#endif#ifndef FOURCC
#define FOURCC unsigned long
#endif//
//
////
// Flags for "avih" chunk
//
#define AVIF_HASINDEX 0x00000010 // Index at end of file
#define AVIF_MUSTUSEINDEX 0x00000020
#define AVIF_ISINTERLEAVED 0x00000100
#define AVIF_TRUSTCKTYPE 0x00000800 // Use CKType to find key frames
#define AVIF_WASCAPTUREFILE 0x00010000
#define AVIF_COPYRIGHTED 0x00020000//
// Flags for "strh" chunk
//
#define AVISF_DISABLED 0x00000001
#define AVISF_VIDEO_PALCHANGES 0x00010000//
// Flags for "idx1" chunk
//
#define AVIIF_LIST 0x00000001L // chunk is a &＃39;LIST&＃39;
#define AVIIF_KEYFRAME 0x00000010L // this frame is a key frame.
#define AVIIF_NOTIME 0x00000100L // this frame doesn&＃39;t take any time
#define AVIIF_COMPUSE 0x0FFF0000L // these bits are for compressor use//
//
//typedef struct
{DWORD dwMicroSecPerFrame; // frame display rate (or 0L)DWORD dwMaxBytesPerSec; // max. transfer rateDWORD dwPaddingGranularity; // pad to multiples of this// size; normally 2K.DWORD dwFlags; // the ever-present flagsDWORD dwTotalFrames; // # frames in fileDWORD dwInitialFrames;DWORD dwStreams;DWORD dwSuggestedBufferSize;DWORD dwWidth;DWORD dwHeight;DWORD dwReserved[4];
} MainAVIHeader;typedef struct {FOURCC fccType;FOURCC fccHandler;DWORD dwFlags; // Contains AVITF_* flagsWORD wPriority;WORD wLanguage;DWORD dwInitialFrames;DWORD dwScale; DWORD dwRate; // dwRate / dwScale &＃61;&＃61; samples/secondDWORD dwStart;DWORD dwLength; // In units above...DWORD dwSuggestedBufferSize;DWORD dwQuality;DWORD dwSampleSize;DWORD dwTop;DWORD dwLeft;DWORD dwRight;DWORD dwBottom;
} AVIStreamHeader;typedef struct
{DWORD ckid;DWORD dwFlags;DWORD dwChunkOffset; // Position of chunkDWORD dwChunkLength; // Length of chunk
} AVIINDEXENTRY;//
//
//#endif _AVIFMT_H_

#ifndef _WRIFF_H_
#define _WRIFF_H_//
//
//
// RIFF.H -- Interface for wrinting RIFF files
//
// By Nitzan Shaked
//
//
//#include
//#include "avifmt.h"
//
//
////
// Chunk types a riff file can contain
//
typedef enum riffSectionType
{RIFF_SECTION_LIST &＃61; 0, // "LIST" (size) "TYPE" (data)RIFF_SECTION_CHUNK &＃61; 1 // "name" (size) (data)
};//
// Structure used to hold information about a chunk
//
typedef struct _riffSection
{riffSectionType type; // LIST or CHUNKlong sizeOffset; // Offset in file where size is to be writtenlong currentSize; // Current size (including subchunks, if any)
} riffSection;//
// Maximum nesting level for riff files
//
#define MAX_RIFF_NESTING_LEVEL 20//
// Stack used to hold current structure of riff file
//
typedef riffSection riffStack[MAX_RIFF_NESTING_LEVEL];//
// Information about one riff file
//
typedef struct _riffFile
{FILE *f; // The file handlerriffStack stack;long stackTop; // Stack top (-1 if empty)
} riffFile;//
// Names and types of lists and chunks
//
typedef char *str4;//
//
////
// Create a new riff file and return a pointer to a "riffFile"
//
// Return NULL if failure
//
riffFile *riffCreate( LPCTSTR filename );//
// Close a riff file
//
bool riffClose( riffFile *f );//
// Pads the file to WORD boundry (adds a 0 byte if necessary)
//
bool riffPadWord( riffFile *f );//
// Pads the file to a given granularity from a given position
//
bool riffPadJunk( riffFile *f,long granularity,long from );//
// Adds a LIST to a riff file
//
bool riffAddList( riffFile *f,str4 type, // "LIST" or "RIFF"str4 name );//
// Adds a CHUNK to a riff file
//
bool riffAddChunk( riffFile *f,str4 name );//
// Writes data to the riff file
//
bool riffWriteData( riffFile *f,void *buf,long size );//
// Returns the current position (size) of the riff file
//
long riffSize( riffFile *f );//
// Closes last section in the riff file
//
bool riffCloseSection( riffFile *f );
bool riffCloseChunk( riffFile *f );
bool riffCloseList( riffFile *f );//
//
//#endif _WRIFF_H_


//
//
//
#include "stdafx.h"
#include
#include
#include #include
#include
#include "avifmt.h"#include "wriff.h"#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] &＃61; __FILE__;
#endif//
//
////riffFile *riffCreate( LPCTSTR filename )
{riffFile *result;if ( (result &＃61; (riffFile*)malloc( sizeof(riffFile) )) &＃61;&＃61; NULL ){//fprintf( stderr, "Error - riffCreate() - can&＃39;t allocate memory for riffFile\n" );return NULL;}if ( (result->f &＃61; fopen( filename, "wb" )) &＃61;&＃61; NULL ){//fprintf( stderr, "Error - riffCreate() - can&＃39;t create <%s>\n", filename );free( result );return NULL;}result->stackTop &＃61; -1;return result;
}//
//
//bool riffClose( riffFile *f )
{while( f->stackTop > -1 ){riffCloseSection( f );}if ( fclose( f->f ) !&＃61; 0 ){// fprintf( stderr, "Error - riffClose() - can&＃39;t close RIFF file\n" );return false;}//free( f );return true;
}//
//
//bool riffPadWord( riffFile *f )
{char dummy &＃61; 0;if ( ftell( f->f ) % 2 &＃61;&＃61; 1 ){fwrite( &dummy, 1, 1, f->f );}return true;
}//
//
//#define MAX_GRAN 2048bool riffPadJunk( riffFile *f,long granularity,long from )
{long currentSize;if ( granularity > MAX_GRAN ){//fprintf( stderr, "Error - riffPadJunk() - granularity greater than %d\n", MAX_GRAN );return false;}if ( f->stack[ f->stackTop ].type !&＃61; RIFF_SECTION_LIST ){//fprintf( stderr, "Error - riffPadJunk() - current section type is not LIST\n" );return false;}currentSize &＃61; ( riffSize( f ) - from ) % granularity;if ( currentSize !&＃61; 0 ){char buf[MAX_GRAN];currentSize &＃61; ( currentSize &＃43; 8 ) % granularity;memset( buf, 0, granularity );riffAddChunk( f, "JUNK" );riffWriteData( f, buf, granularity-currentSize );riffCloseChunk( f );}return true;
}//
//
//bool riffAddList( riffFile *f,str4 type, // "LIST" or "RIFF"str4 name )
{if ( f->stackTop &＃61;&＃61; MAX_RIFF_NESTING_LEVEL ){//fprintf( stderr, "Error - riffAddList() - maximum nesting level reached\n" );return false;}if ( f->stackTop > -1 ){if ( f->stack[ f->stackTop ].type !&＃61; RIFF_SECTION_LIST ){//fprintf( stderr, "Error - riffAddList() - current section type is not LIST\n" );return false;}}(f->stackTop)&＃43;&＃43;;f->stack[ f->stackTop ].type &＃61; RIFF_SECTION_LIST;f->stack[ f->stackTop ].sizeOffset &＃61; ftell( f->f ) &＃43; 4;f->stack[ f->stackTop ].currentSize &＃61; 0;fwrite( type, 1, 4, f->f ); // "LIST" or "RIFF"fwrite( "xxxx", 1, 4, f->f ); // reserve room for sizefwrite( name, 1, 4, f->f );return true;
}//
//
//bool riffAddChunk( riffFile *f,str4 name )
{if ( f->stackTop &＃61;&＃61; MAX_RIFF_NESTING_LEVEL ){//fprintf( stderr, "Error - riffAddChunk() - maximum nesting level reached\n" );return false;}if ( f->stack[ f->stackTop ].type !&＃61; RIFF_SECTION_LIST ){//fprintf( stderr, "Error - riffAddChunk() - current section type is not LIST\n" );return false;}(f->stackTop)&＃43;&＃43;;f->stack[ f->stackTop ].type &＃61; RIFF_SECTION_CHUNK;f->stack[ f->stackTop ].sizeOffset &＃61; ftell( f->f ) &＃43; 4;f->stack[ f->stackTop ].currentSize &＃61; 0;fwrite( name, 1, 4, f->f );fwrite( "xxxx", 1, 4, f->f ); // reserve room for sizereturn true;
}//
//
//bool riffWriteData( riffFile *f,void *buf,long size )
{if ( (long)fwrite( buf, 1, size, f->f ) !&＃61; size ){//fprintf( stderr, "Error - riffWriteData() - fwrite() didn&＃39;t return expected result\n" );return false;}f->stack[ f->stackTop ].currentSize &＃43;&＃61; size;return true;
}//
//
//long riffSize( riffFile *f )
{return ftell( f->f );
}//
//
//bool riffCloseSection( riffFile *f )
{long sizeToAdd;if ( f->stackTop &＃61;&＃61; -1 ){//fprintf( stderr, "Error - riffCloseSection() - stack underflow\n" );return false;}if ( f->stack[ f->stackTop ].type &＃61;&＃61; RIFF_SECTION_LIST ){f->stack[ f->stackTop ].currentSize &＃43;&＃61; 4;}fseek( f->f, f->stack[ f->stackTop ].sizeOffset, SEEK_SET );fwrite( &(f->stack[ f->stackTop ].currentSize), 1, 4, f->f );fseek( f->f, 0, SEEK_END );switch ( f->stack[ f->stackTop ].type ){case RIFF_SECTION_LIST:sizeToAdd &＃61; 12;break;case RIFF_SECTION_CHUNK:sizeToAdd &＃61; 8;break;default://fprintf( stderr, "Error - riffCloseSection() - unexpected section type\n" );sizeToAdd &＃61; 0;}if ( f->stack[ f->stackTop ].type &＃61;&＃61; RIFF_SECTION_LIST ){f->stack[ f->stackTop ].currentSize -&＃61; 4;}if ( f->stackTop > 0 ){f->stack[ f->stackTop - 1 ].currentSize &＃43;&＃61; ( f->stack[ f->stackTop ].currentSize &＃43; sizeToAdd );}(f->stackTop)--;return true;
}//
//
//bool riffCloseChunk( riffFile *f )
{return riffCloseSection( f );
}//
//
//bool riffCloseList( riffFile *f )
{return riffCloseSection( f );
}//
//
//
/**/

#ifndef __CONVERT_TO_AVI__
#define __CONVERT_TO_AVI__#include
#include "AVIFMt.H"
#include "WRIFF.H"#define WRITE_REC_LIST // do write REC list?
#define WRITE_INDEX // do write index?
#define ALIGN_VIDEO_FRAMES // do align video frames?#define MAX_FILE_LEN 2048000000 // the AVI file now can&＃39;t exceed 2G#define PADDING_GRANULARITY 2048 // padding sizetypedef struct
{DWORD dwFrameWidth;DWORD dwFrameHeight;DWORD dwFrameSize;DWORD dwFPS;DWORD dwTotalFrames;
}AVI_CONVERT_PARA;class CConvertAVI
{
public:CConvertAVI();virtual ~CConvertAVI();public:DWORD m_dwCurFrameNum;DWORD m_dwMaxFrames;BOOL m_bWriteHdr;riffFile *m_pOutAVI;AVI_CONVERT_PARA m_strAVIPara;#ifdef WRITE_INDEXAVIINDEXENTRY* m_pIndexes;DWORD m_nMoviOffset;
#endif // WRITE_INDEXDWORD m_dwFirstFrameOffset;public:BOOL WriteHeaders();BOOL AddFileToAVI(char* pBuf, DWORD nSize);BOOL CloseWriffFiles();BOOL InitResource(AVI_CONVERT_PARA* pParam, CString strAVIPath);void ReleaseResource();BOOL IsWriteAVIHdr();BOOL IsExceedMaxFileLen();DWORD GetCurFrameNum();void SetFPS(DWORD nFps);
};#endif

#include "StdAfx.h"
#include "CConvertAVI.h"#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] &＃61; __FILE__;
#endifCConvertAVI::CConvertAVI()
{m_pOutAVI &＃61; NULL;m_pIndexes &＃61; NULL;m_dwMaxFrames &＃61; 0;ZeroMemory(&m_strAVIPara, sizeof(AVI_CONVERT_PARA));
}CConvertAVI::~CConvertAVI()
{
}BOOL CConvertAVI::InitResource(AVI_CONVERT_PARA* pParam, CString strAVIPath)
{m_dwCurFrameNum &＃61; 0;m_dwFirstFrameOffset &＃61; 0;m_bWriteHdr &＃61; TRUE;CopyMemory(&m_strAVIPara, pParam, sizeof(AVI_CONVERT_PARA));m_dwMaxFrames &＃61; MAX_FILE_LEN/m_strAVIPara.dwTotalFrames;#ifdef WRITE_INDEXm_pIndexes &＃61; new AVIINDEXENTRY[m_dwMaxFrames];if(NULL &＃61;&＃61; m_pIndexes){return FALSE;}ZeroMemory(m_pIndexes, m_dwMaxFrames * sizeof(AVIINDEXENTRY));m_nMoviOffset &＃61; 0;
#endif m_pOutAVI &＃61; riffCreate( LPCTSTR(strAVIPath) );if ( m_pOutAVI &＃61;&＃61; NULL ){ReleaseResource();return FALSE;}return TRUE;
}void CConvertAVI::ReleaseResource()
{if(m_pOutAVI !&＃61; NULL){TRACE("Close wriff files.\n");CloseWriffFiles();m_pOutAVI &＃61; NULL;}#ifdef WRITE_INDEXif(m_pIndexes !&＃61; NULL){TRACE("Delete m_pIndexes.\n");delete [] m_pIndexes;m_pIndexes &＃61; NULL;}
#endifZeroMemory(&m_strAVIPara, sizeof(AVI_CONVERT_PARA));
}BOOL CConvertAVI::IsWriteAVIHdr()
{return m_bWriteHdr;
}BOOL CConvertAVI::WriteHeaders()
{MainAVIHeader mainAviHeader;AVIStreamHeader aviStreamHeader;BITMAPINFOHEADER bitmapHeader;DWORD fcc;riffAddList( m_pOutAVI, "RIFF", "AVI " );//// Write hdr1 list//riffAddList( m_pOutAVI, "LIST", "hdrl" );mainAviHeader.dwMicroSecPerFrame &＃61; 1000000 / (m_strAVIPara.dwFPS);mainAviHeader.dwMaxBytesPerSec &＃61; m_strAVIPara.dwFrameSize &＃43; PADDING_GRANULARITY; // SparemainAviHeader.dwPaddingGranularity &＃61; 0;mainAviHeader.dwFlags &＃61; AVIF_HASINDEX;mainAviHeader.dwTotalFrames &＃61; m_strAVIPara.dwTotalFrames;mainAviHeader.dwInitialFrames &＃61; 0;mainAviHeader.dwStreams &＃61; 1;mainAviHeader.dwSuggestedBufferSize &＃61; m_strAVIPara.dwFrameSize &＃43; PADDING_GRANULARITY; // SparemainAviHeader.dwWidth &＃61; m_strAVIPara.dwFrameWidth;mainAviHeader.dwHeight &＃61; m_strAVIPara.dwFrameHeight;mainAviHeader.dwReserved[0] &＃61; 0;mainAviHeader.dwReserved[1] &＃61; 0;mainAviHeader.dwReserved[2] &＃61; 0;mainAviHeader.dwReserved[3] &＃61; 0; riffAddChunk ( m_pOutAVI, "avih" );riffWriteData ( m_pOutAVI, &mainAviHeader, sizeof( mainAviHeader ) );riffCloseChunk( m_pOutAVI );//// Write the "strl" video list//riffAddList( m_pOutAVI, "LIST", "strl" );//// Write the "strh" chunk //fcc &＃61; mmioFOURCC( &＃39;Y&＃39;, &＃39;V&＃39;, &＃39;1&＃39;, &＃39;2&＃39; );aviStreamHeader.fccType &＃61; mmioFOURCC( &＃39;v&＃39;, &＃39;i&＃39;, &＃39;d&＃39;, &＃39;s&＃39; );aviStreamHeader.fccHandler &＃61; 0;aviStreamHeader.dwFlags &＃61; fcc;aviStreamHeader.wPriority &＃61; 0;aviStreamHeader.wLanguage &＃61; 0;aviStreamHeader.dwInitialFrames &＃61; 0;aviStreamHeader.dwScale &＃61; 1;aviStreamHeader.dwRate &＃61; m_strAVIPara.dwFPS;aviStreamHeader.dwStart &＃61; 0;aviStreamHeader.dwLength &＃61; m_strAVIPara.dwTotalFrames;aviStreamHeader.dwSuggestedBufferSize &＃61; m_strAVIPara.dwFrameSize &＃43; PADDING_GRANULARITY;aviStreamHeader.dwQuality &＃61; 0xFFFFFFFF; // -1aviStreamHeader.dwSampleSize &＃61; 0;aviStreamHeader.dwTop &＃61; 0;aviStreamHeader.dwLeft &＃61; 0;aviStreamHeader.dwRight &＃61; 0;aviStreamHeader.dwBottom &＃61; 0;riffAddChunk ( m_pOutAVI, "strh" );riffWriteData ( m_pOutAVI, &aviStreamHeader, sizeof( aviStreamHeader ) );riffCloseChunk( m_pOutAVI );////// Write the "strf" chunk//bitmapHeader.biSize &＃61; sizeof( bitmapHeader );bitmapHeader.biWidth &＃61; m_strAVIPara.dwFrameWidth;bitmapHeader.biHeight &＃61; m_strAVIPara.dwFrameHeight;bitmapHeader.biPlanes &＃61; 1;bitmapHeader.biBitCount &＃61; 12;bitmapHeader.biCompression &＃61; fcc;bitmapHeader.biSizeImage &＃61; m_strAVIPara.dwFrameSize;bitmapHeader.biXPelsPerMeter &＃61; 0;bitmapHeader.biYPelsPerMeter &＃61; 0;bitmapHeader.biClrUsed &＃61; 0;bitmapHeader.biClrImportant &＃61; 0;riffAddChunk ( m_pOutAVI, "strf" );riffWriteData ( m_pOutAVI, &bitmapHeader, sizeof( bitmapHeader ) );riffCloseChunk( m_pOutAVI ); //// Close the strl list//riffCloseList( m_pOutAVI );//// Close the hdrl list//riffCloseList( m_pOutAVI );//// Write JUNK chunk//riffPadJunk( m_pOutAVI, PADDING_GRANULARITY, 0 );//// Write the "movi" list//riffAddList( m_pOutAVI, "LIST", "movi" );m_dwFirstFrameOffset &＃61; riffSize( m_pOutAVI );#ifdef WRITE_INDEXm_nMoviOffset &＃61; m_dwFirstFrameOffset - 4;
#endif//// Return//m_bWriteHdr &＃61; FALSE;return TRUE;
}DWORD CConvertAVI::GetCurFrameNum()
{return m_dwCurFrameNum;
}BOOL CConvertAVI::AddFileToAVI(char* pBuf, DWORD /*nSize*/)
{#ifdef WRITE_REC_LIST//// Write "rec " list//#ifdef WRITE_INDEXriffPadWord( m_pOutAVI );#endif // WRITE_INDEXriffAddList( m_pOutAVI, "LIST", "rec" );#endif // WRITE_REC_LIST//// Write the "00dc" chunk//
#ifdef WRITE_INDEXriffPadWord( m_pOutAVI );m_pIndexes[m_dwCurFrameNum].ckid &＃61; mmioFOURCC( &＃39;0&＃39;, &＃39;0&＃39;, &＃39;d&＃39;, &＃39;c&＃39; );m_pIndexes[m_dwCurFrameNum].dwFlags &＃61; AVIIF_KEYFRAME;m_pIndexes[m_dwCurFrameNum].dwChunkOffset &＃61; riffSize( m_pOutAVI ) - m_nMoviOffset;m_pIndexes[m_dwCurFrameNum].dwChunkLength &＃61; m_strAVIPara.dwFrameSize;#endif // WRITE_INDEX//// Write the chunk//riffAddChunk ( m_pOutAVI, "00dc" );riffWriteData ( m_pOutAVI, pBuf, m_strAVIPara.dwFrameSize ); riffCloseChunk( m_pOutAVI );#ifdef WRITE_REC_LIST//// Close the "rec " list//riffCloseList( m_pOutAVI );#endif // WRITE_REC_LIST//// Write JUNK chunk to align video frames//
#ifdef ALIGN_VIDEO_FRAMESriffPadJunk( m_pOutAVI, PADDING_GRANULARITY, m_dwFirstFrameOffset );#endif // ALIGN_VIDEO_FRAMESm_dwCurFrameNum &＃43;&＃43;;return TRUE;
}BOOL CConvertAVI::CloseWriffFiles()
{//// Close the "movi" list//riffCloseList( m_pOutAVI );//// Write the "idx1" chunk//
#ifdef WRITE_INDEXriffPadWord ( m_pOutAVI );riffAddChunk ( m_pOutAVI, "idx1" );riffWriteData ( m_pOutAVI, m_pIndexes, m_dwCurFrameNum*sizeof( AVIINDEXENTRY) );riffCloseChunk( m_pOutAVI );#endif // WRITE_INDEX//// Close the "RIFF" LIST//riffCloseList( m_pOutAVI );//// Close the riff file//riffClose( m_pOutAVI );return TRUE;
}void CConvertAVI::SetFPS(DWORD nFps)
{m_strAVIPara.dwFPS &＃61; nFps;
}BOOL CConvertAVI::IsExceedMaxFileLen()
{return ( (m_dwCurFrameNum >&＃61; m_dwMaxFrames) ? TRUE : FALSE);
}

文件太多&＃xff0c;完整的工程&＃xff1a;

http://download.csdn.net/download/houwenbin1986/10127294