vfwwnd.cpp

我近期从事视频开发所以将我参考的资料上传给大家看看。

BOOL CAVICapWnd::CaptureNoFile()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SEQUENCE_NOFILE));
}

BOOL CAVICapWnd::SetMCIDevice(const CString& sName)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_MCI_DEVICE, 0, reinterpret_cast<LPARAM>(sName.operator LPCTSTR())));
}

BOOL CAVICapWnd::CaptureSingleFrame()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SINGLE_FRAME));
}

BOOL CAVICapWnd::CaptureSingleFrameOpen()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SINGLE_FRAME_OPEN));
}

BOOL CAVICapWnd::CaptureSingleFrameClose()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SINGLE_FRAME_CLOSE));
}

BOOL CAVICapWnd::EditCopy()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_EDIT_COPY));
}

BOOL CAVICapWnd::SaveDib(const CString& sFilename)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_FILE_SAVEDIB, 0, reinterpret_cast<LPARAM>(sFilename.operator LPCTSTR())));
}

BOOL CAVICapWnd::GrabFrame()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_GRAB_FRAME));  
}

BOOL CAVICapWnd::GrabFrameNoStop()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_GRAB_FRAME_NOSTOP));  
}

BOOL CAVICapWnd::SetInfoChunk(const CAPINFOCHUNK* pInfoChunk)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_FILE_SET_INFOCHUNK, 0, reinterpret_cast<LPARAM>(pInfoChunk)));  
}

DWORD_PTR CAVICapWnd::GetUserData()
{
  return static_cast<DWORD_PTR>(SendMessage(WM_CAP_GET_USER_DATA));
}

BOOL CAVICapWnd::SetUserData(DWORD_PTR dwData)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_USER_DATA, 0, static_cast<LPARAM>(dwData)));  
}

BOOL CAVICapWnd::AutoCreatePalette(int nFrames, int nColors)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_PAL_AUTOCREATE, static_cast<WPARAM>(nFrames), static_cast<LPARAM>(nColors)));  
}

BOOL CAVICapWnd::ManualCreatePalette(BOOL bGrab, int nColors)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_PAL_AUTOCREATE, static_cast<WPARAM>(bGrab), static_cast<LPARAM>(nColors)));  
}

BOOL CAVICapWnd::OpenPalette(const CString& sFilename)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_PAL_OPEN, 0, reinterpret_cast<LPARAM>(sFilename.operator LPCTSTR())));
}

BOOL CAVICapWnd::PastePalette()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_PAL_PASTE));
}

BOOL CAVICapWnd::SavePalette(const CString& sFilename)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_PAL_SAVE, 0, reinterpret_cast<LPARAM>(sFilename.operator LPCTSTR())));
}

BOOL CAVICapWnd::GetSetup(CAPTUREPARMS& params)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_GET_SEQUENCE_SETUP, static_cast<WPARAM>(sizeof(params)), reinterpret_cast<LPARAM>(&params)));  
}

BOOL CAVICapWnd::SetSetup(CAPTUREPARMS& params)
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_SEQUENCE_SETUP, static_cast<WPARAM>(sizeof(params)), reinterpret_cast<LPARAM>(&params)));  
}

#ifdef _DEBUG
LRESULT CAVICapWnd::OnControl(int nState)
#else
LRESULT CAVICapWnd::OnControl(int /*nState*/)
#endif
{
#ifdef _DEBUG
  //Just TRACE the message, derived classes can do something more interesting
  TRACE(_T("CAVICapWnd::OnControl, Received CAPCONTROL callback, State=%d\n"), nState);
#endif  
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_Control(HWND hWnd, int nState)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnControl(nState);
}

BOOL CAVICapWnd::EnableCapControlCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_CAPCONTROL, 0, reinterpret_cast<LPARAM>(_Control)));
}

BOOL CAVICapWnd::RemoveCapControlCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_CAPCONTROL, 0, NULL));
}

#ifdef _DEBUG
LRESULT CAVICapWnd::OnError(int nID, LPCTSTR lpsz)
#else
LRESULT CAVICapWnd::OnError(int /*nID*/, LPCTSTR /*lpsz*/)
#endif
{
  //Just TRACE the message, derived classes can do something more interesting
#ifdef _DEBUG  
  TRACE(_T("CAVICapWnd::OnError, Received Error callback, ID=%d, String=%s\n"), nID, lpsz);
#endif  
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_Error(HWND hWnd, int nID, LPCTSTR lpsz)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnError(nID, lpsz);
}

BOOL CAVICapWnd::EnableErrorCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_ERROR, 0, reinterpret_cast<LPARAM>(_Error)));
}

BOOL CAVICapWnd::RemoveErrorCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_ERROR, 0, NULL));
}

LRESULT CAVICapWnd::OnFrame(LPVIDEOHDR /*lpVHdr*/)
{
  //Just TRACE the message, derived classes can do something more interesting
  TRACE(_T("CAVICapWnd::OnFrame, Received Frame callback\n"));
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_Frame(HWND hWnd, LPVIDEOHDR lpVHdr)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnFrame(lpVHdr);
}

BOOL CAVICapWnd::EnableFrameCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_FRAME, 0, reinterpret_cast<LPARAM>(_Frame)));
}

BOOL CAVICapWnd::RemoveFrameCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_FRAME, 0, NULL));
}

#ifdef _DEBUG
LRESULT CAVICapWnd::OnStatus(int nID, LPCTSTR lpsz)
#else
LRESULT CAVICapWnd::OnStatus(int /*nID*/, LPCTSTR /*lpsz*/)
#endif
{
  //Just TRACE the message, derived classes can do something more interesting
#ifdef _DEBUG  
  TRACE(_T("CAVICapWnd::OnStatus, Received Status callback, ID=%d, String=%s\n"), nID, lpsz);
#endif  
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_Status(HWND hWnd, int nID, LPCTSTR lpsz)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnStatus(nID, lpsz);
}

BOOL CAVICapWnd::EnableStatusCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_STATUS, 0, reinterpret_cast<LPARAM>(_Status)));
}

BOOL CAVICapWnd::RemoveStatusCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_STATUS, 0, NULL));
}

LRESULT CAVICapWnd::OnVideoStream(LPVIDEOHDR /*lpVHdr*/)
{
  //Just TRACE the message, derived classes can do something more interesting
  TRACE(_T("CAVICapWnd::OnVideoStream, Received VideoStream callback\n"));
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_VideoStream(HWND hWnd, LPVIDEOHDR lpVHdr)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnVideoStream(lpVHdr);
}

BOOL CAVICapWnd::EnableVideoStreamCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, reinterpret_cast<LPARAM>(_VideoStream)));
}

BOOL CAVICapWnd::RemoveVideoStreamCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, NULL));
}

LRESULT CAVICapWnd::OnWaveStream(LPWAVEHDR /*lpWHdr*/)
{
  //Just TRACE the message, derived classes can do something more interesting
  TRACE(_T("CAVICapWnd::OnWaveStream, Received WaveStream callback\n"));
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_WaveStream(HWND hWnd, LPWAVEHDR lpWHdr)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnWaveStream(lpWHdr);
}

BOOL CAVICapWnd::EnableWaveStreamCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_WAVESTREAM, 0, reinterpret_cast<LPARAM>(_WaveStream)));
}

BOOL CAVICapWnd::RemoveWaveStreamCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_WAVESTREAM, 0, NULL));
}

LRESULT CAVICapWnd::OnYield()
{
  //Just TRACE the message, derived classes can do something more interesting
  TRACE(_T("CAVICapWnd::OnYield, Received Yield callback\n"));
  return static_cast<LRESULT>(TRUE);
}

LRESULT CALLBACK CAVICapWnd::_Yield(HWND hWnd)
{
  //Convert from the SDK world to the C++ world
  CAVICapWnd* pWnd = static_cast<CAVICapWnd*>(CWnd::FromHandle(hWnd));
  ASSERT(pWnd);
  ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CAVICapWnd)));

  //Call the member function
  return pWnd->OnYield();
}

BOOL CAVICapWnd::EnableYieldCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_YIELD, 0, reinterpret_cast<LPARAM>(_Yield)));
}

BOOL CAVICapWnd::RemoveYieldCallback()
{
  return static_cast<BOOL>(SendMessage(WM_CAP_SET_CALLBACK_YIELD, 0, NULL));
}