开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
vfw.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：12k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

vfw.cxx：源码内容
  1. /*
  2.  * vfw.cxx
  3.  *
  4.  * Classes to support streaming video input (grabbing) and output.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-2000 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Contributor(s): ______________________________________.
  25.  *
  26.  * $Log: vfw.cxx,v $
  27.  * Revision 1.4  2000/07/26 03:50:50  robertj
  28.  * Added last error variable to video device.
  29.  *
  30.  * Revision 1.3  2000/07/25 13:38:26  robertj
  31.  * Added frame rate parameter to video frame grabber.
  32.  *
  33.  * Revision 1.2  2000/07/25 13:14:07  robertj
  34.  * Got the video capture stuff going!
  35.  *
  36.  * Revision 1.1  2000/07/15 09:47:35  robertj
  37.  * Added video I/O device classes.
  38.  *
  39.  */
  41. #include <ptlib.h>
  42. #include <ptlib/videoio.h>
  45. class PVideoInputThread : public PThread
  46. {
  47.   PCLASSINFO(PVideoInputThread, PThread);
  48.   public:
  49.     PVideoInputThread(PVideoInputDevice & dev)
  50.       : PThread(30000, NoAutoDeleteThread, HighPriority), device(dev) { Resume(); }
  51.     void Main() { device.HandleCapture(); }
  52.   protected:
  53.     PVideoInputDevice & device;
  54. };
  57. ///////////////////////////////////////////////////////////////////////////////
  59. class PCapStatus : public CAPSTATUS
  60. {
  61.   public:
  62.     PCapStatus(HWND hWnd);
  63.     BOOL IsOK() { return uiImageWidth != 0; }
  64. };
  67. ///////////////////////////////////////////////////////////////////////////////
  69. class PVideoDeviceBitmap : PBYTEArray
  70. {
  71.   public:
  72.     PVideoDeviceBitmap(unsigned width, unsigned height, PVideoDevice::ColourFormat fmt);
  73.     PVideoDeviceBitmap(HWND hWnd);
  74.     BOOL ApplyFormat(HWND hWnd) { return capSetVideoFormat(hWnd, theArray, GetSize()); }
  76.     BITMAPINFO * operator->() const { return (BITMAPINFO *)theArray; }
  77. };
  81. ///////////////////////////////////////////////////////////////////////////////
  83. PVideoDeviceBitmap::PVideoDeviceBitmap(unsigned width, unsigned height,
  84.                                        PVideoDevice::ColourFormat fmt)
  85.   : PBYTEArray(sizeof(BITMAPINFO))
  86. {
  87.   PINDEX i;
  88.   BITMAPINFO * bi = (BITMAPINFO *)theArray;
  90.   bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  91.   bi->bmiHeader.biWidth = width;
  92.   bi->bmiHeader.biHeight = height;
  93.   bi->bmiHeader.biPlanes = 1;
  95.   switch (fmt) {
  96.     case PVideoDevice::Grey :
  97.       bi->bmiHeader.biCompression = BI_RGB;
  98.       bi->bmiHeader.biBitCount = 8;
  99.       SetSize(sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256);
  100.       for (i = 0; i < 256; i++)
  101.         bi->bmiColors[i].rgbBlue = bi->bmiColors[i].rgbGreen = bi->bmiColors[i].rgbRed = (BYTE)i;
  102.       break;
  103.     case PVideoDevice::RGB24 :
  104.       bi->bmiHeader.biCompression = BI_RGB;
  105.       bi->bmiHeader.biBitCount = 24;
  106.       break;
  107.     case PVideoDevice::RGB32 :
  108.       bi->bmiHeader.biCompression = BI_RGB;
  109.       bi->bmiHeader.biBitCount = 32;
  110.       break;
  111.     case PVideoDevice::YUV422 :
  112.       bi->bmiHeader.biCompression = mmioFOURCC('Y', 'U', 'V', '8');
  113.       bi->bmiHeader.biBitCount = 8;
  114.       break;
  115.     case PVideoDevice::RGB565 :
  116.       bi->bmiHeader.biCompression = BI_BITFIELDS;
  117.       bi->bmiHeader.biBitCount = 16;
  118.       break;
  119.     case PVideoDevice::MJPEG :
  120.       bi->bmiHeader.biCompression = mmioFOURCC('M','J','P','G');
  121.       bi->bmiHeader.biBitCount = 0;
  122.       break;
  123.   }
  125.   bi->bmiHeader.biSizeImage = height*((bi->bmiHeader.biBitCount*width + 31)/32)*4;
  126. }
  129. PVideoDeviceBitmap::PVideoDeviceBitmap(HWND hCaptureWindow)
  130. {
  131.   PINDEX sz = capGetVideoFormatSize(hCaptureWindow);
  132.   SetSize(sz);
  133.   if (capGetVideoFormat(hCaptureWindow, theArray, sz))
  134.     return;
  136.   PTRACE(1, "capGetVideoFormat: failed - " << ::GetLastError());
  137.   SetSize(0);
  138. }
  141. ///////////////////////////////////////////////////////////////////////////////
  143. PCapStatus::PCapStatus(HWND hWnd)
  144. {
  145.   memset(this, 0, sizeof(*this));
  146.   if (capGetStatus(hWnd, this, sizeof(*this)))
  147.     return;
  149.   PTRACE(1, "capGetStatus: failed - " << ::GetLastError());
  150. }
  153. ///////////////////////////////////////////////////////////////////////////////
  154. // PVideoDevice
  156. PVideoInputDevice::PVideoInputDevice(VideoFormat videoFmt,
  157.                                      unsigned channel,
  158.                                      ColourFormat colourFmt)
  159.   : PVideoDevice(videoFmt, channel, colourFmt)
  160. {
  161.   captureThread = NULL;
  162.   hCaptureWindow = NULL;
  163. }
  166. BOOL PVideoInputDevice::Open(const PString & devName, BOOL startImmediate)
  167. {
  168.   Close();
  170.   deviceName = devName;
  172.   captureThread = new PVideoInputThread(*this);
  173.   threadStarted.Wait();
  174.   if (hCaptureWindow == NULL) {
  175.     delete captureThread;
  176.     captureThread = NULL;
  177.     return FALSE;
  178.   }
  180.   if (startImmediate)
  181.     return Start();
  183.   return TRUE;
  184. }
  187. BOOL PVideoInputDevice::IsOpen() const
  188. {
  189.   return hCaptureWindow != NULL;
  190. }
  193. BOOL PVideoInputDevice::Close()
  194. {
  195.   if (!IsOpen())
  196.     return FALSE;
  198.   Stop();
  200.   ::PostThreadMessage(captureThread->GetThreadId(), WM_QUIT, 0, 0L);
  201.   captureThread->WaitForTermination();
  202.   delete captureThread;
  203.   captureThread = NULL;
  205.   return TRUE;
  206. }
  209. BOOL PVideoInputDevice::Start()
  210. {
  211.   if (capCaptureSequenceNoFile(hCaptureWindow))
  212.     return TRUE;
  214.   lastError = ::GetLastError();
  215.   PTRACE(1, "capCaptureSequenceNoFile: failed - " << lastError);
  216.   return FALSE;
  217. }
  220. BOOL PVideoInputDevice::Stop()
  221. {
  222.   if (capCaptureStop(hCaptureWindow))
  223.     return TRUE;
  225.   lastError = ::GetLastError();
  226.   PTRACE(1, "capCaptureStop: failed - " << lastError);
  227.   return FALSE;
  228. }
  231. BOOL PVideoInputDevice::IsCapturing()
  232. {
  233.   PCapStatus status(hCaptureWindow);
  234.   return status.fCapturingNow;
  235. }
  238. BOOL PVideoInputDevice::SetFrameRate(unsigned rate)
  239. {
  240.   if (!PVideoDevice::SetFrameRate(rate))
  241.     return FALSE;
  243.   BOOL running = IsCapturing();
  244.   if (running)
  245.     Stop();
  247.   CAPTUREPARMS parms;
  248.   memset(&parms, 0, sizeof(parms));
  250.   if (!capCaptureGetSetup(hCaptureWindow, &parms, sizeof(parms))) {
  251.     lastError = ::GetLastError();
  252.     PTRACE(1, "capCaptureGetSetup: failed - " << lastError);
  253.     return FALSE;
  254.   }
  256.   parms.dwRequestMicroSecPerFrame = 100000000 / frameRate;
  257.   parms.fMakeUserHitOKToCapture = FALSE;
  258.   parms.wPercentDropForError = 100;
  259.   parms.fCaptureAudio = FALSE;
  260.   parms.fAbortLeftMouse = FALSE;
  261.   parms.fAbortRightMouse = FALSE;
  262.   parms.fLimitEnabled = FALSE;
  264.   if (!capCaptureSetSetup(hCaptureWindow, &parms, sizeof(parms))) {
  265.     lastError = ::GetLastError();
  266.     PTRACE(1, "capCaptureSetSetup: failed - " << lastError);
  267.     return FALSE;
  268.   }
  270.   if (running)
  271.     return Start();
  273.   return TRUE;
  274. }
  277. BOOL PVideoInputDevice::SetFrameSize(unsigned width, unsigned height)
  278. {
  279.   if (!PVideoDevice::SetFrameSize(width, height))
  280.     return FALSE;
  282.   BOOL running = IsCapturing();
  283.   if (running)
  284.     Stop();
  286.   ::SetWindowPos(hCaptureWindow, NULL, 0, 0,
  287.                  width + GetSystemMetrics(SM_CXFIXEDFRAME),
  288.                  height + GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFIXEDFRAME),
  289.                  SWP_NOMOVE|SWP_NOACTIVATE);
  291.   PCapStatus status(hCaptureWindow);
  292.   if (status.IsOK()) {
  293.     frameWidth = status.uiImageWidth;
  294.     frameHeight = status.uiImageHeight;
  295.   }
  297.   if (running)
  298.     return Start();
  300.   return TRUE;
  301. }
  304. BOOL PVideoInputDevice::SetColourFormat(ColourFormat colourFmt)
  305. {
  306.   BOOL running = IsCapturing();
  307.   if (running)
  308.     Stop();
  310.   ColourFormat oldFormat = colourFormat;
  312.   if (!PVideoDevice::SetColourFormat(colourFmt))
  313.     return FALSE;
  315.   PVideoDeviceBitmap bitmapInfo(frameWidth, frameHeight, colourFmt);
  316.   if (!bitmapInfo.ApplyFormat(hCaptureWindow)) {
  317.     lastError = ::GetLastError();
  318.     PTRACE(1, "capSetVideoFormat: failed - " << lastError);
  319.     PVideoDevice::SetColourFormat(oldFormat);
  320.     return FALSE;
  321.   }
  323.   if (running)
  324.     return Start();
  326.   return TRUE;
  327. }
  330. PStringList PVideoInputDevice::GetDeviceNames() const
  331. {
  332.   PStringList list;
  334.   for (WORD devId = 0; devId < 10; devId++) {
  335.     char name[100];
  336.     char version[200];
  337.     if (capGetDriverDescription(devId, name, sizeof(name), version, sizeof(version)))
  338.       list.AppendString(name);
  339.   }
  341.   return list;
  342. }
  345. PINDEX PVideoInputDevice::GetMaxFrameBytes()
  346. {
  347.   return PVideoDeviceBitmap(hCaptureWindow)->bmiHeader.biSizeImage;
  348. }
  351. BOOL PVideoInputDevice::GetFrameData(BYTE * buffer, PINDEX * bytesReturned)
  352. {
  353.   if (!frameAvailable.Wait(1000))
  354.     return FALSE;
  356.   lastFrameMutex.Wait();
  357.   memcpy(buffer, lastFramePtr, lastFrameSize);
  358.   if (bytesReturned != NULL)
  359.     *bytesReturned = lastFrameSize;
  360.   lastFrameMutex.Signal();
  362.   return TRUE;
  363. }
  366.     
  367. LRESULT CALLBACK PVideoInputDevice::ErrorHandler(HWND hWnd, int id, LPCSTR err)
  368. {
  369.   if (hWnd == NULL)
  370.     return FALSE;
  372.   return ((PVideoInputDevice *)capGetUserData(hWnd))->HandleError(id, err);
  373. }
  376. LRESULT PVideoInputDevice::HandleError(int id, LPCSTR err)
  377. {
  378.   if (id != 0) {
  379.     PTRACE(1, "ErrorHandler: [id="<< id << "] " << err);
  380.   }
  382.   return TRUE;
  383. }
  386. LRESULT CALLBACK PVideoInputDevice::VideoHandler(HWND hWnd, LPVIDEOHDR vh)
  387. {
  388.   if (hWnd == NULL)
  389.     return FALSE;
  391.   return ((PVideoInputDevice *)capGetUserData(hWnd))->HandleVideo(vh);
  392. }
  395. LRESULT PVideoInputDevice::HandleVideo(LPVIDEOHDR vh)
  396. {
  397.   if (vh->dwFlags & VHDR_DONE) {
  398.     lastFrameMutex.Wait();
  399.     lastFramePtr = vh->lpData;
  400.     lastFrameSize = vh->dwBytesUsed;
  401.     lastFrameMutex.Signal();
  402.     frameAvailable.Signal();
  403.   }
  405.   return TRUE;
  406. }
  409. BOOL PVideoInputDevice::InitialiseCapture()
  410. {
  411.   if ((hCaptureWindow = capCreateCaptureWindow("Capture Window",
  412.                                                WS_POPUP | WS_CAPTION,
  413.                                                CW_USEDEFAULT, CW_USEDEFAULT,
  414.                                                frameWidth + GetSystemMetrics(SM_CXFIXEDFRAME),
  415.                                                frameHeight + GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFIXEDFRAME),
  416.                                                (HWND)0,
  417.                                                0)) == NULL) {
  418.     lastError = ::GetLastError();
  419.     PTRACE(1, "capCreateCaptureWindow: failed");
  420.     return FALSE;
  421.   }
  423.   capSetCallbackOnError(hCaptureWindow, ErrorHandler);
  425.   if (!capSetCallbackOnVideoStream(hCaptureWindow, VideoHandler)) {
  426.     lastError = ::GetLastError();
  427.     PTRACE(1, "capSetCallbackOnVideoStream: failed - " << lastError);
  428.     return FALSE;
  429.   }
  431.   WORD devId;
  432.   if (deviceName.GetLength() == 1 && isdigit(deviceName[0]))
  433.     devId = (WORD)(deviceName[0] - '0');
  434.   else {
  435.     for (devId = 0; devId < 10; devId++) {
  436.       char name[100];
  437.       char version[200];
  438.       if (capGetDriverDescription(devId, name, sizeof(name), version, sizeof(version)) &&
  439.           (deviceName *= name))
  440.         break;
  441.     }
  442.   }
  444.   // Use first driver available.
  445.   if (!capDriverConnect(hCaptureWindow, devId)) {
  446.     lastError = ::GetLastError();
  447.     PTRACE(1, "capDriverConnect: failed - " << lastError);
  448.     return FALSE;
  449.   }
  451.   capSetUserData(hCaptureWindow, this);
  453.   CAPDRIVERCAPS driverCaps;
  454.   memset(&driverCaps, 0, sizeof(driverCaps));
  455.   if (!capDriverGetCaps(hCaptureWindow, &driverCaps, sizeof(driverCaps))) {
  456.     lastError = ::GetLastError();
  457.     PTRACE(1, "capGetDriverCaps: failed - " << lastError);
  458.     return FALSE;
  459.   }
  461.   if (driverCaps.fHasOverlay)
  462.     capOverlay(hCaptureWindow, TRUE);
  463.   else {
  464.     capPreviewRate(hCaptureWindow, 66);
  465.     capPreview(hCaptureWindow, TRUE);
  466.   }
  468.   if (!SetFrameRate(frameRate))
  469.     return FALSE;
  471.   if (!SetFrameSize(frameWidth, frameHeight))
  472.     return FALSE;
  474.   return SetColourFormat(colourFormat);
  475. }
  478. void PVideoInputDevice::HandleCapture()
  479. {
  480.   if (InitialiseCapture()) {
  481.     threadStarted.Signal();
  482.     MSG msg;
  483.     while (::GetMessage(&msg, NULL, 0, 0))
  484.       ::DispatchMessage(&msg);
  485.   }
  487.   capDriverDisconnect(hCaptureWindow);
  488.   capSetCallbackOnVideoStream(hCaptureWindow, NULL);
  490.   DestroyWindow(hCaptureWindow);
  491.   hCaptureWindow = NULL;
  493.   threadStarted.Signal();
  494. }
  497. // End Of File ///////////////////////////////////////////////////////////////