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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
DXManager.cpp
资源名称：handvu-beta3.tar.gz　[点击查看]
上传用户：lijia5631
上传日期：2008-11-10
资源大小：1214k
文件大小：26k
源码类别：

视频捕捉/采集

开发平台：

MultiPlatform

DXManager.cpp：源码内容
  1. /**   * HandVu - a library for computer vision-based hand gesture   * recognition.   * Copyright (C) 2004 Mathias Kolsch, matz@cs.ucsb.edu   *   * This program is free software; you can redistribute it and/or   * modify it under the terms of the GNU General Public License   * as published by the Free Software Foundation; either version 2   * of the License, or (at your option) any later version.   *   * This program is distributed in the hope that it will be useful,   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * GNU General Public License for more details.   *   * You should have received a copy of the GNU General Public License   * along with this program; if not, write to the Free Software   * Foundation, Inc., 59 Temple Place - Suite 330,    * Boston, MA  02111-1307, USA.   *   * $Id: DXManager.cpp,v 1.14 2005/10/30 23:00:43 matz Exp $ **/ #include "stdafx.h"
  2. #include "HandVuFilterGUIDs.h"
  3. #include <initguid.h> // need this before MainFrm.h
  4. #include "Common.h"
  5. #include "DXManager.h"
  6. #include "DXAppView.h"
  7. #include "Dvdmedia.h"
  8. #include "Exceptions.h"
  10. DXManager::DXManager() :
  11.   m_video_scale(1.0),
  12.   m_pParentView(NULL),
  13.   m_handvu_logfilename(""),
  14.   m_two_windows(false)
  15. {
  16.   NullComPtrs();
  18.   /*
  19.   // start GestureEventServer
  20.   int m_gesture_server_port = 7047;
  21.   int m_osc_port = 57120;
  22.   string m_osc_ip = "128.111.28.75"; 
  23. //  string m_osc_ip = "localhost"; 
  24.   m_pGestureServer = new CGestureEventServer(m_gesture_server_port);
  25.   m_pGestureServer->UseOSC(m_osc_ip, m_osc_port);
  26.   m_pGestureServer->Start();
  27. */
  29.   // for event timestamps
  30.   _ftime(&m_startTime);
  32.   // debugging
  33.   m_ROTregister   = 0;
  34. //  DbgInitialise(g_hInst);
  35.   DbgSetModuleLevel(LOG_CUSTOM1, 3);
  36. }
  38. DXManager::~DXManager()
  39. {
  40.   StopPlayback();
  41.   DestroyFilterGraph();
  43. //  DbgDumpObjectRegister();
  44. //  DbgTerminate();
  45. }
  47. void DXManager::NullComPtrs()
  48. {
  49.   m_GraphBuilder = NULL;
  50.   m_MediaControl = NULL;
  51.   m_MediaEventEx = NULL;
  52.   m_FilterGraph = NULL;
  53.   m_HandVuFilterProp = NULL;
  54.   m_HandVuFilter = NULL;
  55.   m_SourceFilter = NULL;
  56.   m_CameraControl = NULL;
  57.   m_VideoWindow = NULL;
  58.   m_SourceVideoWindow = NULL;
  59.   m_pIAMTCReader = NULL;
  60. }
  62. void DXManager::StartPlayback() 
  63. {
  64.   if (m_HandVuFilterProp) {
  65.     HRESULT hr = m_HandVuFilterProp->AddListener(this);
  66.     ASSERT(SUCCEEDED(hr));
  67.   }
  68.   if (m_MediaControl) {
  69.     m_VideoWindow->put_Owner((OAHWND)m_pParentView->m_hWnd);
  70.     m_VideoWindow->put_WindowStyle(WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN);
  71.     m_VideoWindow->put_MessageDrain((OAHWND)m_pParentView->m_hWnd);
  72.     m_VideoWindow->put_Visible(OATRUE);
  73.     /*
  74.     if (m_MediaEventEx) {
  75.       // Have the graph signal event via window callbacks for performance
  76.       m_MediaEventEx->SetNotifyWindow((OAHWND)m_hWnd, WM_GRAPHNOTIFY, 0);
  77.     }
  78.     */
  79.     m_MediaControl->Run();
  80.   }
  81. }
  83. void DXManager::StopPlayback() 
  84. {
  85.   if (m_HandVuFilterProp) {
  86.     HRESULT hr = m_HandVuFilterProp->RemoveListener(this);
  87.     ASSERT(SUCCEEDED(hr));
  89.   }
  90.   if (m_MediaControl) {
  91.     m_MediaControl->Stop();
  92.     m_VideoWindow->put_Visible(OAFALSE);
  93.     m_VideoWindow->put_Owner(NULL);
  94.     m_VideoWindow->put_MessageDrain(0);
  95.   }
  96. }
  98. bool DXManager::BuildGraph(bool two_windows, CDXAppView* parent)
  99. {
  100.   m_pParentView = parent;
  101.   m_two_windows = two_windows;
  102.   DestroyFilterGraph();
  103.   bool success = RealBuildGraph();
  104.   if (!success) {
  105.     DestroyFilterGraph();
  106.   }
  107.   return success;
  108. }
  110. void DXManager::FrameTransformed(bool processed)
  111. {
  112. }
  114. IHandVuFilter* DXManager::HV()
  115. {
  116.   ASSERT(m_HandVuFilterProp);
  117.   return m_HandVuFilterProp.p;
  118. }
  120. void DXManager::ToggleExposureControl()
  121. {
  122.   SetExposureControl(-1);
  123. }
  125. void DXManager::SetExposureControl(int on/*=1*/)
  126. {
  127.   if (!m_CameraControl) {
  128.     return;
  129.   }
  131.   if (!m_HandVuFilterProp) {
  132.     return;
  133.   }
  135.   bool possible;
  136.   HRESULT hr = m_HandVuFilterProp->CanAdjustExposure(&possible);
  137.   ASSERT(SUCCEEDED(hr));
  138.   if (!possible) {
  139.     return;
  140.   }
  142.   if (on==-1) {
  143.     bool is_on;
  144.     hr = m_HandVuFilterProp->IsAdjustingExposure(&is_on);
  145.     ASSERT(SUCCEEDED(hr));
  146.     on = is_on?0:1;
  147.   }
  149.   if (on) {
  150.     hr = m_HandVuFilterProp->SetAdjustExposure(true);
  151.     ASSERT(SUCCEEDED(hr));
  152.   } else {
  153.     // turn it off in HandVu
  154.     hr = m_HandVuFilterProp->SetAdjustExposure(false);
  155.     ASSERT(SUCCEEDED(hr));
  156.     // turn Auto exposure on in the camera itself
  157.     SetCameraAutoExposure(true);
  158.   }
  159. }
  161. /* CameraControl function
  162. * returns true if camera was successfully set to adjust the exposure
  163. */
  164. bool DXManager::SetCameraAutoExposure(bool enable)  {   long exposure, flags;
  165.   HRESULT hr = m_CameraControl->Get(CameraControl_Exposure, &exposure, &flags);
  166.   if (SUCCEEDED(hr)) {
  167.     if (enable) {
  168.       flags = CameraControl_Flags_Auto;
  169.     } else {
  170.       flags = CameraControl_Flags_Manual;
  171.     }
  172.     hr = m_CameraControl->Set(CameraControl_Exposure, exposure, flags);
  173.     if (SUCCEEDED(hr)) {
  174.       VERBOSE1(3, "camera does %sauto-expose now", ((enable)?"":"not "));
  175.     }
  176.   }
  177.   if (!SUCCEEDED(hr)) {
  178.     VERBOSE0(2, "can't set camera to do auto-exposure");
  179.   }
  181.   return (SUCCEEDED(hr));
  182. } /* CameraControl function
  183. */
  184. double DXManager::GetCurrentExposure()  {   if (!m_CameraControl) {
  185.     throw HVException("no camera control found");
  186.   }
  187.   long minExp, maxExp, stepping_delta, dflt, flags;
  188.   HRESULT hr = m_CameraControl->GetRange(CameraControl_Exposure, &minExp, &maxExp, 
  189.     &stepping_delta, &dflt, &flags);
  190.   if (!SUCCEEDED(hr)) {
  191.     throw HVException("could not get exposure range from camera control");
  192.   }
  193.   
  194.   long currExp;
  195.   hr = m_CameraControl->Get(CameraControl_Exposure, &currExp, &flags);
  196.   if (!SUCCEEDED(hr)) {
  197.     throw HVException("could not get current exposure from camera control");
  198.   }
  199.   
  200.   double newval = (double)(currExp-minExp)/(double)(maxExp-minExp);
  202.   VERBOSE1(5, "DXManager: GetCurrentExposure = %f",
  203.     (float)newval);
  205.   return newval;
  206. } /* CameraControl function
  207. * true if change has an effect, false if step is too small */
  208. bool DXManager::SetExposure(double exposure)  {   VERBOSE1(5, "DXManager: SetExposure(%f) ...",
  209.     (float)exposure);
  211.   if (!m_CameraControl) {
  212.     throw HVException("no camera control found");
  213.   }
  215.   long minExp, maxExp, stepping_delta, dflt, flags;
  216.   HRESULT hr = m_CameraControl->GetRange(CameraControl_Exposure, &minExp, &maxExp, 
  217.     &stepping_delta, &dflt, &flags);
  218.   if (!SUCCEEDED(hr)) {
  219.     throw HVException("could not get exposure range from camera control");
  220.   }
  221.   
  222.   long oldExp;
  223.   hr = m_CameraControl->Get(CameraControl_Exposure, &oldExp, &flags);
  224.   if (!SUCCEEDED(hr)) {
  225.     throw HVException("could not get current exposure from camera control");
  226.   }
  228.   int newExp = (int) (exposure*(maxExp-minExp) + minExp);
  230.   flags = CameraControl_Flags_Manual;
  231.   hr = m_CameraControl->Set(CameraControl_Exposure, newExp, flags);
  232.   if (!SUCCEEDED(hr)) {
  233.     throw HVException("could not set new exposure for camera control");
  234.   }
  236.   long currExp;
  237.   hr = m_CameraControl->Get(CameraControl_Exposure, &currExp, &flags);
  238.   if (!SUCCEEDED(hr)) {
  239.     throw HVException("could not get current exposure from camera control");
  240.   }
  242.   VERBOSE1(5, "DXManager: SetExposure completed (%s)",
  243.     (oldExp!=currExp)?"changed":"unchanged");
  245.   return oldExp!=currExp;
  246. } /* CameraControl function
  247. */
  248. bool DXManager::CanAdjustExposure()  {   return m_CameraControl!=NULL;
  249. }
  253. void DXManager::ToggleFullscreen()
  254. {
  255.   long fullscreen;
  256.   CComPtr<IVideoWindow> vw = NULL;
  257.   vw = m_VideoWindow;
  258.   HRESULT hr = vw->get_FullScreenMode(&fullscreen);
  259.   if (SUCCEEDED(hr)) {
  260.     if (fullscreen==OATRUE) {
  261.       fullscreen = OAFALSE;
  262.       ReleaseCapture();
  263.       ShowCursor(true);
  264.       m_pParentView->SetTrapMouse(false);
  265.     } else {
  266.       ASSERT(fullscreen==OAFALSE);
  267.       fullscreen = OATRUE;
  268.       SetCapture(m_pParentView->m_hWnd);
  269.       ShowCursor(false);
  270.       m_pParentView->SetTrapMouse(true);
  271.     }
  272.    hr = vw->put_FullScreenMode(fullscreen);
  273.   }
  274.   if (!SUCCEEDED(hr)) {
  275.     AfxMessageBox("can not render in full-screen mode");
  276.   }
  277. }
  281. bool DXManager::RealBuildGraph()
  282. {
  283.   HRESULT hr;
  284. //  hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, 
  285. //                        IID_ICaptureGraphBuilder2, (void **)&m_GraphBuilder);
  286.   hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, 
  287.                         IID_IGraphBuilder, (void **)&m_GraphBuilder);
  288.   if (!SUCCEEDED(hr) || !m_GraphBuilder) { 
  289.     AfxMessageBox("Can't access graph builder interface");
  290.     return false; 
  291.   }
  293.   CreateCamera();
  294.   if (m_SourceFilter==0) {
  295.     AfxMessageBox("Can't connect to a camera");
  296.     return false;
  297.   }
  299.   if (!CreateHandVuFilter()) {
  300.     AfxMessageBox("Can't create HandVu filter");
  301.     return false;
  302.   }
  305.   /* create generic graph objects */
  306.   m_GraphBuilder->QueryInterface(IID_IMediaControl,(void**)&m_MediaControl);
  307.   m_GraphBuilder->QueryInterface(IID_IMediaEventEx,(void**)&m_MediaEventEx);
  308.   m_GraphBuilder->QueryInterface(IID_IVideoWindow, (void**)&m_VideoWindow );
  309.   m_GraphBuilder->QueryInterface(IID_IFilterGraph, (void**)&m_FilterGraph);
  311.   if (!m_FilterGraph) {
  312.     AfxMessageBox("Can't access filter graph interface");
  313.     return false;
  314.   }
  316.   if (!ConnectFilters()) {
  317.     int device;
  318.     for (device=1; device<=10; device++) {
  319.       CreateCamera(device);
  320.       if (ConnectFilters()) {
  321.         break;
  322.       }
  323.     }
  324.     if (device==11) {
  325.       AfxMessageBox("Can't connect to a camera, tried 10 devices");
  326.       return false;
  327.     }
  328.   }
  329. #ifdef DEBUG
  330.   // ROT debugging stuff
  331.   hr = AddToROT(m_GraphBuilder, &m_ROTregister);
  332.   ASSERT(SUCCEEDED(hr));
  333. #endif // DEBUG
  335.   return true;
  336. }
  338. /* link the created filters */
  339. bool DXManager::ConnectFilters()
  340. {
  341.   HRESULT hr;
  342.   bool success = false;
  344.   CComPtr<IPin> pSourceOut          = NULL;
  345.   CComPtr<IPin> pHandVuIn           = NULL;
  346.   CComPtr<IPin> pHandVuOut          = NULL;
  347.   CComPtr<IBaseFilter> pSmartTee    = NULL;
  348.   CComPtr<IBaseFilter> pColorConv   = NULL;
  349.   CComPtr<IPin> pProcessThis        = NULL;
  350.   CComPtr<IBaseFilter> pAppRenderer = NULL;
  351.   CComPtr<IPin> pSmartTPreviewOut   = NULL;
  354.   // get a video output pin
  355.   hr = AddFilter(m_SourceFilter, L"Video Source" );
  356.   pSourceOut = GetVideoPin(m_SourceFilter, PINDIR_OUTPUT);
  357.   if (!SUCCEEDED(hr) || pSourceOut==NULL) goto release_and_return;
  359.   // make two application windows
  360.   if (!m_two_windows) {
  361.     pProcessThis = pSourceOut;
  362.   } else {
  363.     hr = CoCreateInstance(CLSID_SmartTee, NULL, CLSCTX_INPROC_SERVER, 
  364.                       IID_IBaseFilter, (void**)&pSmartTee);
  365.     if (!SUCCEEDED(hr)) goto release_and_return;
  367.     hr = AddFilter(pSmartTee, L"SmartT");
  368.     CComPtr<IPin> pSmartTIn         = GetPin(pSmartTee, PINDIR_INPUT);
  369.     CComPtr<IPin> pSmartTCaptureOut = GetPin(pSmartTee, PINDIR_OUTPUT, 0);//, &PIN_CATEGORY_CAPTURE);
  370.     pSmartTPreviewOut = GetPin(pSmartTee, PINDIR_OUTPUT, 1);//, &PIN_CATEGORY_PREVIEW);
  371.     if (!SUCCEEDED(hr) || !pSmartTIn || !pSmartTCaptureOut || !pSmartTPreviewOut) goto release_and_return;
  373.     hr = ConnectPins(pSourceOut, pSmartTIn);
  374.     if (!SUCCEEDED(hr)) goto release_and_return;
  376.     hr = CoCreateInstance( CLSID_VideoRenderer, NULL, CLSCTX_INPROC_SERVER, 
  377.       IID_IBaseFilter, (void**)&pAppRenderer );
  378.     if (!SUCCEEDED(hr)) goto release_and_return;
  380.     pAppRenderer->QueryInterface(IID_IVideoWindow,(void**)&m_SourceVideoWindow);
  381.     if (!SUCCEEDED(hr) || !m_SourceVideoWindow) goto release_and_return;
  383.     m_SourceWin.m_pDXManager = this;
  384.     if (m_SourceWin.m_hWnd==NULL) {
  385.   //    m_SourceWin.CreateEx(NULL, "", "source display", WS_POPUP | WS_MAXIMIZE, CRect(10, 10, 300, 200), m_pParent, 1, NULL);
  386.       m_SourceWin.Create(NULL, "source display", WS_CHILD, CRect(50, 50, 160, 120), m_pParentView, 1, NULL);
  387.     }
  388.     m_SourceVideoWindow->put_Owner((OAHWND)m_SourceWin.m_hWnd);
  389.     m_SourceVideoWindow->put_MessageDrain((OAHWND)m_SourceWin.m_hWnd);
  390.     m_SourceVideoWindow->SetWindowPosition(50, 50, 160, 120);
  392.     hr = CoCreateInstance( CLSID_Colour, NULL, CLSCTX_INPROC_SERVER, 
  393.     IID_IBaseFilter, (void**)&pColorConv );
  394.     if (!SUCCEEDED(hr) || !pColorConv) goto release_and_return;
  395.     CComPtr<IPin> pColorConvIn    = GetPin(pColorConv, PINDIR_INPUT);
  396.     CComPtr<IPin> pColorConvOut   = GetPin(pColorConv, PINDIR_OUTPUT);
  397.     hr = AddFilter(pColorConv, L"Source Renderer" );
  398.     if (!SUCCEEDED(hr)) goto release_and_return;
  400.     hr = ConnectPins(pSmartTCaptureOut, pColorConvIn );
  401.     if (!SUCCEEDED(hr)) goto release_and_return;
  403.     pSmartTIn.Release();
  405.     pProcessThis = pColorConvOut;
  406.   }
  408.   hr = AddFilter(m_HandVuFilter, L"HandVuFilter");
  409.   pHandVuIn         = GetPin(m_HandVuFilter, PINDIR_INPUT);
  410.   pHandVuOut        = GetPin(m_HandVuFilter, PINDIR_OUTPUT);
  411.   if (!SUCCEEDED(hr) || !pHandVuIn || !pHandVuOut) goto release_and_return;
  413.   hr = ConnectPins(pProcessThis, pHandVuIn);      
  414.   if (!SUCCEEDED(hr)) goto release_and_return;
  416.   if (!InitHandVuFilter()) goto release_and_return;
  418.   hr = m_GraphBuilder->Render(pHandVuOut);
  419.   if (!SUCCEEDED(hr)) goto release_and_return;
  421.   if (m_two_windows) {
  422.     CComPtr<IPin> pAppRendererIn    = GetPin(pAppRenderer, PINDIR_INPUT);
  423.     hr = AddFilter(pAppRenderer, L"Source Renderer" );
  424.     if (!SUCCEEDED(hr) || !pAppRendererIn) goto release_and_return;
  426.     hr = ConnectPins(pSmartTPreviewOut, pAppRendererIn );
  427.     if (!SUCCEEDED(hr)) goto release_and_return;
  429.     m_SourceWin.EnableWindow(TRUE);
  430.     m_SourceWin.Invalidate();
  432.     pAppRenderer.Release();
  433.     pAppRendererIn.Release();
  434. //    pSmartTCaptureOut.Release();
  436.   }
  438.   success = true;
  440. release_and_return:
  441.   pProcessThis.Release();
  442.   pHandVuIn.Release();
  443.   pHandVuOut.Release();
  444.   pSmartTee.Release();
  445.   pAppRenderer.Release();
  446.   pSmartTPreviewOut.Release();
  448.   return success;
  449. }
  453. // Destroy DirectShow Filter Graph
  454. void DXManager::DestroyFilterGraph()
  455. {
  456.   if (m_FilterGraph) {
  457.     CComPtr<IEnumFilters> pEnumFilters = 0;
  458.     m_FilterGraph->EnumFilters( &pEnumFilters );
  460.     if( pEnumFilters ) {
  461.       CComPtr<IBaseFilter> pFilter = 0;
  462.       ULONG cFetched = 0;
  464.       while( pEnumFilters->Next( 1, &pFilter, &cFetched ) == S_OK && pFilter != 0 ) {
  465.         m_FilterGraph->RemoveFilter( pFilter );
  466.         pFilter.Release();
  467.         cFetched = 0;
  468.       }
  469.       pEnumFilters.Release();
  470.     }
  471.   }
  472. #ifdef DEBUG
  473.   RemoveFromROT(m_ROTregister);
  474. #endif
  476.   m_GraphBuilder.Release();
  477.   m_MediaControl.Release();
  478.   m_MediaEventEx.Release();
  479.   m_FilterGraph.Release();
  480.   m_HandVuFilter.Release();
  481.   m_HandVuFilterProp.Release();
  482.   m_SourceFilter.Release();
  483.   m_CameraControl.Release();
  484.   m_VideoWindow.Release();
  485.   m_SourceVideoWindow.Release();
  487.   NullComPtrs();
  488. }
  492. bool DXManager::CreateHandVuFilter()
  493. {
  494.   HRESULT hr = CoCreateInstance( CLSID_HandVuFilter, NULL, CLSCTX_INPROC_SERVER, 
  495.                              IID_IBaseFilter, (void**)&m_HandVuFilter );
  496.   if (SUCCEEDED(hr)) {
  497.     m_HandVuFilter->QueryInterface(IID_IHandVuFilter, (void**)&m_HandVuFilterProp);
  498.   }
  499.   if (m_HandVuFilterProp) {
  500.     
  501.     hr = m_HandVuFilterProp->AddListener(this);
  502.     ASSERT(SUCCEEDED(hr));
  503.     
  504.     if (m_pIAMTCReader) {
  505.       hr = m_HandVuFilterProp->SetTimecodeReader(m_pIAMTCReader);
  506.       ASSERT(SUCCEEDED(hr));
  507.     }
  509.     hr = m_HandVuFilterProp->SetVerbosity(g_verbose, m_handvu_logfilename);
  510.     ASSERT(SUCCEEDED(hr));
  511.   }
  512.   return m_HandVuFilterProp != 0;
  513. }
  515. bool DXManager::InitHandVuFilter()
  516. {
  517.   ASSERT(m_SourceFilter);
  519.   CComPtr<IPin> pPin = GetVideoPin(m_SourceFilter, PINDIR_OUTPUT);
  520.   AM_MEDIA_TYPE media_type;
  521.   pPin->ConnectionMediaType(&media_type);
  522.   BITMAPINFOHEADER* pHdr=NULL;
  523.   if (media_type.formattype==FORMAT_VideoInfo) {
  524.     pHdr = &((VIDEOINFOHEADER*) media_type.pbFormat)->bmiHeader;
  525.   } else if (media_type.formattype==FORMAT_VideoInfo2) {
  526.     pHdr = &((VIDEOINFOHEADER2*) media_type.pbFormat)->bmiHeader;
  527.   } else {
  528.     return false;
  529.   }
  531.   ASSERT(pHdr);
  532.   int width = pHdr->biWidth;
  533. int height = pHdr->biHeight;
  534.   int iPixelSize = pHdr->biBitCount / 8;
  535.   HRESULT hr = m_HandVuFilterProp->Initialize(width, height, iPixelSize, this);
  536.   ASSERT(SUCCEEDED(hr));
  538.   return SUCCEEDED(hr);
  539. }
  542. bool DXManager::CreateCamera( int idx )
  543. {
  544.   CComPtr<ICreateDevEnum> pCreateDevEnum = 0;
  545.   CComPtr<IEnumMoniker>   pEnumMon = 0;
  546.   ULONG           cFetched = 0;
  548.   m_SourceFilter.Release();
  550.   CoCreateInstance( CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
  551.                 IID_ICreateDevEnum, (void**)&pCreateDevEnum );
  553.   /* Create capture device */
  554.   if( pCreateDevEnum ) {
  555.     CComPtr<IMoniker> pMon = 0;
  556.     pCreateDevEnum->CreateClassEnumerator( CLSID_VideoInputDeviceCategory, &pEnumMon, 0);
  558.     if( pEnumMon && idx > 0 ) {
  559.       pEnumMon->Skip( idx );
  560.       ASSERT(0); // need to give user a choice
  561.     }
  562.     if( pEnumMon && SUCCEEDED( pEnumMon->Next(1, &pMon, &cFetched)) && cFetched == 1 ) {
  563.       pMon->BindToObject(0, 0, IID_IBaseFilter, (void **)&m_SourceFilter );
  564.       pMon.Release();
  565.     }
  566.     pEnumMon.Release();
  567.     pCreateDevEnum.Release();
  568.   }
  570.   if (!m_SourceFilter) {
  571.     // try file input
  572.     CFileDialog open_dlg(true, 0, 0, OFN_FILEMUSTEXIST, 
  573.       "All Media Files (*.avi;*.mpg;*.mpeg;*.mov;*.wm;*.wmv;*.wma)|*.avi; *.mpg; *.mpeg; *.mov; *.wm; *.wmv; *.wma|"
  574.       "Movie Files (*.avi;*.mpg;*.mpeg;*.mov)|*.avi; *.mpg; *.mpeg; *.mov|"
  575.       "Windows Media Files (*.wm;*.wmv;*.wma)|*.wm;*.wmv;*.wma|"
  576.       "All Files (*.*)|*.*||");
  578.     if (open_dlg.DoModal()==IDOK) {
  579.       CString str = open_dlg.GetPathName();
  580.       if (str.GetLength()>0) {
  581.         WCHAR wname[1000] = L"";
  582.         MultiByteToWideChar( CP_ACP, 0, str, -1, wname, sizeof(wname)/2 );
  584.         HRESULT hr = m_GraphBuilder->AddSourceFilter(wname, L"Mmh da sauze filter", &m_SourceFilter);
  585.         if (!SUCCEEDED(hr) || m_SourceFilter==NULL) {
  586.           VERBOSE0(3, "DXManager: could not add source filter");
  587.           return false;
  588.         }
  589.       }
  590.     }
  591.   }
  593.   if (m_SourceFilter) {
  594.     HRESULT hr = m_SourceFilter->QueryInterface(IID_IAMCameraControl, (void **)&m_CameraControl);
  595.     if (SUCCEEDED(hr) && m_CameraControl) {
  596.       VERBOSE0(5, "IAMCameraControl is implemented");
  597.       // make sure it works
  598.       try {
  599.         double exposure = GetCurrentExposure();
  600.         double new_exposure = SetExposure(exposure);
  601.       } catch (HVException& hve) {
  602.         VERBOSE1(2, "IAMCameraControl operation test failed: %s",
  603.           hve.GetMessage().c_str());
  604.         m_CameraControl.Release();
  605.         m_CameraControl = NULL;
  606.       }
  607.       if (m_CameraControl) {
  608.         VERBOSE0(5, "IAMCameraControl functional - got CameraController");
  609.       }
  610.     } else {
  611.       VERBOSE0(2, "IAMCameraControl not implemented");
  612.     }
  614.     hr = m_SourceFilter->QueryInterface(IID_IAMTimecodeReader, (void **) &m_pIAMTCReader);
  615.     if (!SUCCEEDED(hr)) {
  616.       VERBOSE0(3, "DXManager: no DV TimecodeReader available");
  617.       m_pIAMTCReader = NULL;
  618.     }
  619.   }
  621.   return m_SourceFilter != 0;
  622. }
  629. #ifdef DEBUG
  630. /////////////////////////////////////////////////////////////////////////////
  631. // this allows GraphEdit to connect to the filter graph
  632. // (File ... connect)
  633. HRESULT DXManager::AddToROT(IUnknown *pUnkGraph, DWORD *pdwRegister) 
  634. {
  635.   IMoniker * pMoniker;
  636.   IRunningObjectTable *pROT;
  637.   if (FAILED(GetRunningObjectTable(0, &pROT))) {
  638.     return E_FAIL;
  639.   }
  640.   int const sz = 256;
  641.   WCHAR wsz[sz];
  642.   size_t cbDest = sz * sizeof(WCHAR);
  643. //  StringCbPrintfW(wsz, cbDest, L"FilterGraph %08p pid %08x", (DWORD *) pUnkGraph, GetCurrentProcessId());
  644.   wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD *) pUnkGraph, GetCurrentProcessId());
  645.   HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
  646.   //HRESULT hr = CreateItemMoniker(L"!", L"HandVuDXApp", &pMoniker);
  647.   if (SUCCEEDED(hr)) {
  648.     hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);
  649.     pMoniker->Release();
  650.   }
  651.   pROT->Release();
  652.   return hr;
  653. }
  655. /////////////////////////////////////////////////////////////////////////////
  656. // remove filter graph from Running Object Table
  657. void DXManager::RemoveFromROT(DWORD pdwRegister)
  658. {
  659.   IRunningObjectTable *pROT;
  660.   if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
  661.     pROT->Revoke(pdwRegister);
  662.     pROT->Release();
  663.   }
  664. }
  665. #endif // DEBUG
  668. void DXManager::GetVideoSourceSize(int* pWidth, int* pHeight) 
  669. {
  670.   *pWidth = -1;
  671. *pHeight = -1;
  672.   if (m_SourceFilter!=0) {
  673.     CComPtr<IPin> pPin = GetVideoPin(m_SourceFilter, PINDIR_OUTPUT);
  674.     AM_MEDIA_TYPE media_type;
  675.     pPin->ConnectionMediaType(&media_type);
  676.     BITMAPINFOHEADER* pHdr=NULL;
  677.     if (media_type.formattype==FORMAT_VideoInfo) {
  678.       pHdr = &((VIDEOINFOHEADER*) media_type.pbFormat)->bmiHeader;
  679.     } else if (media_type.formattype==FORMAT_VideoInfo2) {
  680.       pHdr = &((VIDEOINFOHEADER2*) media_type.pbFormat)->bmiHeader;
  681.     }
  682.     if (pHdr!=NULL) {
  683.       *pWidth = pHdr->biWidth;
  684.    *pHeight = abs(pHdr->biHeight);
  685.       VERBOSE2(4, "DXManager: got real size %d %d", *pWidth, *pHeight);
  686.     }
  687.   } 
  688.   if (*pWidth==-1 || *pHeight==-1)  {
  689.     *pWidth = 640;
  690.   *pHeight = 480;
  691.     VERBOSE2(4, "DXManager: got fake size %d %d", *pWidth, *pHeight);
  692.   }
  693. }
  695. void DXManager::SetVideoWindowPosition(int left, int top, int width, int height) 
  696. {
  697.   if (m_VideoWindow) {
  698.     VERBOSE4(4, "DXManager: setting left %d, top %d, width %d, height %d", 
  699.       left, top, width, height);
  700.     m_VideoWindow->SetWindowPosition( left, top, width, height );
  701.   }
  702. }
  704. void DXManager::SetSourceVideoWindowPosition(int left, int top, int width, int height) 
  705. {
  706.   if (m_SourceVideoWindow) {
  707.     m_SourceVideoWindow->SetWindowPosition( left, top, width, height );
  708.   }
  709. }
  711. HRESULT DXManager::AddFilter(IBaseFilter* filter, LPCWSTR name) {
  712.   HRESULT hr = m_FilterGraph->AddFilter(filter, name);
  713. #ifdef DEBUG
  714.   if (!SUCCEEDED(hr)) {
  715.     char buf[MAX_ERROR_TEXT_LEN];
  716.     AMGetErrorText(hr, buf, MAX_ERROR_TEXT_LEN);
  717.     ASSERT(0);
  718.   }
  719. #endif // DEBUG
  720.   return hr;
  721. }
  723. HRESULT DXManager::ConnectPins(IPin* from, IPin* to) {
  724.   HRESULT hr = m_GraphBuilder->Connect(from, to);
  725. #ifdef DEBUG
  726.   if (!SUCCEEDED(hr)) {
  727.     char buf[MAX_ERROR_TEXT_LEN];
  728.     AMGetErrorText(hr, buf, MAX_ERROR_TEXT_LEN);
  729.     ASSERT(0);
  730.   }
  731. #endif // DEBUG
  732.   return hr;
  733. }
  735. void DXManager::GetVersion(string& version) const
  736. {
  737.   string dxm_version = "DXManager: $Id: DXManager.cpp,v 1.14 2005/10/30 23:00:43 matz Exp $";
  738.   string filter_version = "no HandVuFilter loaded";
  739.   if (m_HandVuFilterProp) {
  740.     HRESULT hr = m_HandVuFilterProp->GetVersion(filter_version);
  741.     ASSERT(SUCCEEDED(hr));
  742.   }
  743.   version = dxm_version + "n" + filter_version;
  744. }
  747. BOOL PinMatchesCategory(CComPtr<IPin> pPin, const GUID& Category)
  748. {
  749.   if (pPin == NULL) {
  750.     return false;
  751.   }
  753.   BOOL bFound = FALSE;
  754.   IKsPropertySet *pKs;
  755.   HRESULT hr = pPin->QueryInterface(IID_IKsPropertySet, (void **)&pKs);
  756.   if (SUCCEEDED(hr))
  757.   {
  758.     GUID PinCategory;
  759.     DWORD cbReturned;
  760.     hr = pKs->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, NULL, 0, 
  761.       &PinCategory, sizeof(GUID), &cbReturned);
  762.     if (SUCCEEDED(hr))
  763.     {
  764.       bFound = (PinCategory == Category);
  765.     }
  766.     pKs->Release();
  767.   }
  768.   return bFound;
  769. }
  771. static CComPtr<IPin> GetPin(CComPtr<IBaseFilter> pFilter, PIN_DIRECTION PinDir, int skip/*=0*/, const GUID* pCategory /*= NULL*/)
  772. {
  773.     CComPtr<IEnumPins>  pEnum;
  774.     CComPtr<IPin>       pPin;
  776.     HRESULT hr = pFilter->EnumPins(&pEnum);
  777.     if (FAILED(hr)) {
  778.         return NULL;
  779.     }
  780.     while((hr=pEnum->Next(1, &pPin.p, 0)) == S_OK) {
  781.         PIN_DIRECTION PinDirThis;
  782.         pPin->QueryDirection(&PinDirThis);
  783.         if (PinDir==PinDirThis) {
  784.           if (pCategory==NULL || PinMatchesCategory(pPin, *pCategory)) {
  785.             if (skip) {
  786.               skip--;
  787.             } else {
  788.               break;
  789.             }
  790.           }
  791.         }
  792.         pPin.Release();
  793.     }
  794.     pEnum.Release();
  795.     return pPin;  
  796. }
  798. // get a video output pin
  799. static CComPtr<IPin> GetVideoPin(CComPtr<IBaseFilter> pFilter, PIN_DIRECTION PinDir) //, int skip/*=0*/, const GUID* pCategory /*= NULL*/)
  800. {
  801.   CComPtr<IPin>       pPin;
  803.   bool got_one = false;
  804.   int skip = 0;
  805.   BITMAPINFOHEADER* pHdr=NULL;
  806.   do {
  807.     pPin = GetPin(pFilter, PINDIR_OUTPUT, skip);
  808.     if (pPin==NULL) {
  809.       return NULL;
  810.     }
  812.     CComPtr<IEnumMediaTypes> pEnum;
  813.     HRESULT hr = pPin->EnumMediaTypes(&pEnum);
  814.     if (!SUCCEEDED(hr) || !pEnum) return NULL;
  815.     AM_MEDIA_TYPE* pMediaType = NULL;
  816.     hr = pEnum->Next(1, &pMediaType, NULL);
  817.     while (hr==S_OK) {
  818.       if (pMediaType->formattype==FORMAT_VideoInfo || 
  819.           pMediaType->majortype==MEDIATYPE_Video || 
  820.           pMediaType->majortype==MEDIATYPE_Interleaved || 
  821.           pMediaType->majortype==MEDIATYPE_Stream || 
  822.           pMediaType->majortype==MEDIATYPE_AnalogVideo) 
  823.       {
  824.         DeleteMediaType(pMediaType);
  825.         pMediaType = NULL;
  826.         got_one = true;
  827.         break;
  828.       }
  829.       DeleteMediaType(pMediaType);
  830.       pMediaType = NULL;
  831.       hr = pEnum->Next(1, &pMediaType, NULL);
  832.     }
  833.     skip++;
  834.     if (!got_one) {
  835.       pPin.Release();
  836.     }
  837.   } while (!got_one);
  839.   return pPin;
  840. }
  849. IMPLEMENT_DYNCREATE(CSourceView, CScrollView)
  851. BEGIN_MESSAGE_MAP(CSourceView, CScrollView)
  852.   ON_WM_SIZE()
  853. END_MESSAGE_MAP()
  856. CSourceView::CSourceView()
  857. {
  858. }
  860. CSourceView::~CSourceView()
  861. {
  862. }
  864. BOOL CSourceView::PreCreateWindow(CREATESTRUCT& cs)
  865. {
  866. return CView::PreCreateWindow(cs);
  867. }
  869. void CSourceView::OnInitialUpdate()
  870. {
  871. CScrollView::OnInitialUpdate();
  872.   SetVideoWindowSize(0, 0);
  873. }
  875. void CSourceView::OnSize(UINT nType, int cx, int cy) 
  876. {
  877. CScrollView::OnSize(nType, cx, cy);
  879.   SetVideoWindowSize(cx, cy);
  880. Invalidate(true);
  881. }
  883. void CSourceView::SetVideoWindowSize(int width, int height) 
  884. {
  885.   int source_width, source_height;
  886.   m_pDXManager->GetVideoSourceSize(&source_width, &source_height);
  887.   if (source_height<0) {
  888.     source_height = -source_height;
  889.   }
  890.   CRect rc;
  891.   GetClientRect( &rc );
  892.   if (width==0 && height==0) {
  893.     width = source_width;
  894.     height = source_height;
  895. //      MoveWindow(&rc);
  896.   } else {
  897.     width = max(width, source_width);
  898.     height = max(height, source_height);
  899.     double ratio = (double)source_width/(double)source_height;
  900.     width = min(width, (int)((double)height*ratio));
  901.     height = min(height, (int)((double)width/ratio));
  902.   }
  903.   m_pDXManager->SetSourceVideoWindowPosition( rc.left, rc.top, width, height );
  905. SetScrollSizes(MM_TEXT, CSize(source_width, source_height));
  906. }