home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Game Programming for Teens / VBGPFT.cdr / DirectX8 / dx8a_sdk.exe / samples / multimedia / directshow / capture / dvapp / dvapp.cpp next >
Encoding:
C/C++ Source or Header  |  2000-10-09  |  204.8 KB  |  4,098 lines
  1. //------------------------------------------------------------------------------
  2. // File: DVApp.cpp
  3. //
  4. // Desc: DirectShow sample code - DV control/capture example.
  5. //
  6. // Copyright (c) 1993 - 2000, Microsoft Corporation.  All rights reserved.
  7. //------------------------------------------------------------------------------
  8.  
  9.  
  10. #include "dvapp.h"
  11.  
  12. /*-------------------------------------------------------------------------
  13. Routine:        WinMain
  14. Purpose:        Program entry point      
  15. Arguments:    Usual
  16. Returns:        Usual
  17. Notes:          Sets up window capabilities, initializes & creates the required DirectShow interface & filters.
  18. ------------------------------------------------------------------------*/
  19. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
  20.                     PSTR szCmdLine, int iCmdShow)
  21. {
  22.     static TCHAR    szAppName[] = APPNAME ;
  23.     MSG                 msg ;
  24.     WNDCLASSEX wndclass ;
  25.     HMENU           hmenu;
  26.  
  27.     // Set the Window Parameters   
  28.     wndclass.cbSize        = sizeof (wndclass) ;
  29.     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
  30.     wndclass.lpfnWndProc   = DV_WndProc ;
  31.     wndclass.cbClsExtra    = 0 ;
  32.     wndclass.cbWndExtra    = 0 ;
  33.     wndclass.hInstance     = hInstance ;
  34.     wndclass.hIcon         = LoadIcon (hInstance, TEXT("DVICON")) ;
  35.     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  36.     wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
  37.     wndclass.lpszMenuName  = NULL ;
  38.     wndclass.lpszClassName = szAppName ;
  39.     wndclass.hIconSm       = LoadIcon(hInstance, TEXT("DVICON"));
  40.     // create & setup the window
  41.     RegisterClassEx (&wndclass) ;
  42.     hmenu = LoadMenu(hInstance, MAKEINTRESOURCE(IDR_MENU1));
  43.     g_hwndApp = CreateWindow  (szAppName,            // window class name
  44.                             DV_APPTITLE,             // window caption
  45.                             WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,     // window style
  46.                             CW_USEDEFAULT,           // initial x position
  47.                             CW_USEDEFAULT,           // initial y position
  48.                             g_iAppWidth,             // initial x size
  49.                             g_iAppHeight,            // initial y size
  50.                             NULL,                    // parent window handle
  51.                             hmenu,                   // window menu handle
  52.                             hInstance,               // program instance handle
  53.                             NULL) ;                   // creation parameters
  54.     
  55.     ShowWindow (g_hwndApp, iCmdShow) ;
  56.     UpdateWindow (g_hwndApp) ;
  57.  
  58.     // Initialize UI & Logging levels
  59.     SetWindowText(g_hwndApp, TEXT("Initializing..."));
  60.     CheckMenuItem(hmenu, IDM_LEVEL_SUCCINCT, MF_CHECKED);
  61.     CheckMenuItem(hmenu, IDM_PRIORITY_ERROR, MF_CHECKED);
  62.  
  63.     // Register for device add/remove notifications.
  64.     DEV_BROADCAST_DEVICEINTERFACE filterData;
  65.     ZeroMemory(&filterData, sizeof(DEV_BROADCAST_DEVICEINTERFACE));
  66.     
  67.     filterData.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
  68.     filterData.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
  69.     filterData.dbcc_classguid = AM_KSCATEGORY_CAPTURE;
  70.  
  71.     g_pUnregisterDeviceNotification = NULL;
  72.     g_pRegisterDeviceNotification = NULL;
  73.     // dynload device removal APIs
  74.     {
  75.         HMODULE hmodUser = GetModuleHandle(TEXT("user32.dll"));
  76.         ASSERT(hmodUser);       // we link to user32
  77.         g_pUnregisterDeviceNotification = (PUnregisterDeviceNotification)
  78.             GetProcAddress(hmodUser, "UnregisterDeviceNotification");
  79.  
  80.         // m_pRegisterDeviceNotification is prototyped differently in unicode
  81.         g_pRegisterDeviceNotification = (PRegisterDeviceNotification)
  82.             GetProcAddress(hmodUser,
  83. #ifdef UNICODE
  84.                            "RegisterDeviceNotificationW"
  85. #else
  86.                            "RegisterDeviceNotificationA"
  87. #endif
  88.                            );
  89.         // failures expected on older platforms.
  90.         ASSERT(g_pRegisterDeviceNotification && g_pUnregisterDeviceNotification ||
  91.                !g_pRegisterDeviceNotification && !g_pUnregisterDeviceNotification);
  92.     }
  93.  
  94.     g_hDevNotify = NULL;
  95.  
  96.     if (g_pRegisterDeviceNotification)
  97.     {
  98.         g_hDevNotify = g_pRegisterDeviceNotification(g_hwndApp, &filterData, DEVICE_NOTIFY_WINDOW_HANDLE);
  99.         ASSERT(g_hDevNotify != NULL);
  100.     }
  101.  
  102.     // Setup & Initialize the device & filtergraph
  103.     DV_AppSetup();
  104.  
  105.     // Message processing loop
  106.     while (GetMessage (&msg, NULL, 0, 0))
  107.     {
  108.         TranslateMessage (&msg) ;
  109.         DispatchMessage (&msg) ;
  110.     }
  111.     return (int) msg.wParam;
  112. }
  113.  
  114.  
  115. /*-------------------------------------------------------------------------
  116. Routine:        DV_TransportCommand_WndProc 
  117. Purpose:        Message Handler to control transport state of the device & the filtergraph state
  118. Arguments:    Usual message processing parameters
  119. Returns:        Usual
  120. Notes:          Handles for the Toolbar button controls
  121. ------------------------------------------------------------------------*/
  122. void CALLBACK DV_TransportCommand_WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
  123. {
  124.     HMENU       hmenu;   
  125.     switch (iMsg)
  126.     {
  127.     case WM_COMMAND :
  128.         hmenu = GetMenu(hwnd);
  129.         switch (LOWORD (wParam))
  130.         {
  131.     /*
  132.         The VCR Tool bar commands need to behave differently depending on the 
  133.         current graph.  
  134.  
  135.         In Preview (default) mode, the VCR commands should simply
  136.         control the VCR functions on the vcr device.
  137.  
  138.         In DV To File mode, or File To DV mode the commands should start and stop the graph, 
  139.         as  well as control the vcr mode (although we will disable some buttons to avoid confusion)
  140.     */
  141.         case IDM_PLAY :
  142.         {
  143.             //check if the current graph is a transmit graph
  144.             if (GRAPH_FILE_TO_DV == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE == g_iCurrentGraph || 
  145.                 GRAPH_FILE_TO_DV_TYPE2 == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE_TYPE2 == g_iCurrentGraph)
  146.             {
  147.                 // update the toolbar accordingly
  148.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  149.                 //update the status bar with the dropped frames information
  150.                 g_CapStartTime = GetTickCount();
  151.                 SetTimer(hwnd, DV_TIMER_FRAMES,  DV_TIMERFREQ, (TIMERPROC) DV_DroppedFrameProc);
  152.                 // run the filter graph & wait for dshow events
  153.                 DV_StartGraph();
  154.                 IMediaEventEx *pMe = NULL;
  155.                 if (SUCCEEDED(g_pGraphBuilder->QueryInterface(IID_IMediaEventEx, reinterpret_cast<PVOID *>(&pMe))))
  156.                 {
  157.                     pMe->SetNotifyWindow((LONG_PTR) g_hwndApp, WM_FGNOTIFY, 0);
  158.                     SAFE_RELEASE(pMe);
  159.                 } 
  160.             } 
  161.             else
  162.             {
  163.                 // play the tape for the capture or preview graph
  164.                 DV_PutVcrMode(ED_MODE_PLAY);
  165.  
  166.                 // run the filter graph too if it is preview
  167.                 if(GRAPH_PREVIEW == g_iCurrentGraph)
  168.                     DV_StartGraph();
  169.                 //do we want to display timecodes?
  170.                 if (IsDlgButtonChecked(g_hwndTBar, IDC_TCCHECKBOX))
  171.                 {
  172.                     SetTimer(hwnd, DV_TIMER_ATN,  DV_TIMERFREQ, (TIMERPROC) DV_TimecodeTimerProc);
  173.                     g_bUseAtnTimer = TRUE;
  174.                 } 
  175.             } 
  176.             break;
  177.         }
  178.  
  179.         /*
  180.             The record button starts the *entire* graph, so preview (if selected), won't
  181.             start until the recording starts.  
  182.         */
  183.         case IDM_RECORD :
  184.             // update the toolbar accordingly
  185.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  186.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  187.  
  188.             // check to see if it is a capture graph
  189.             if (GRAPH_DV_TO_FILE == g_iCurrentGraph || GRAPH_DV_TO_FILE_NOPRE == g_iCurrentGraph ||
  190.                 GRAPH_DV_TO_FILE_TYPE2 == g_iCurrentGraph || GRAPH_DV_TO_FILE_NOPRE_TYPE2 == g_iCurrentGraph)
  191.             {
  192.                 //do something here to record to an avi file on the disk - or to start recording on the vcr.
  193.                 switch (g_dwCaptureLimit)
  194.                 {
  195.                     case DV_CAPLIMIT_NONE :
  196.                         break;
  197.                     case DV_CAPLIMIT_TIME :
  198.                         SetTimer(hwnd, DV_TIMER_CAPLIMIT, g_dwTimeLimit * 1000, (TIMERPROC) DV_StopRecProc);
  199.                         break;
  200.                     case DV_CAPLIMIT_SIZE :
  201.                         //rather than monitor disk usage, we'll just do the math and set a timer
  202.                         SetTimer(hwnd, DV_TIMER_CAPLIMIT, ((g_dwDiskSpace * 100000) / DV_BYTESPERMSEC), (TIMERPROC) DV_StopRecProc);
  203.                         break;
  204.                     default :
  205.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Bad value for g_dwCaptureLimit (%d)"), g_dwCaptureLimit);
  206.                         break;
  207.                 }
  208.                 //update the status bar with the dropped frames information
  209.                 g_CapStartTime = GetTickCount();
  210.                 SetTimer(hwnd, DV_TIMER_FRAMES,  DV_TIMERFREQ, (TIMERPROC) DV_DroppedFrameProc);
  211.                 //run the graph - assume that the camera is already playing if in Vcr mode
  212.                 DV_StartGraph();             
  213.             } 
  214.             else if (GRAPH_FILE_TO_DV == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE == g_iCurrentGraph ||
  215.                      GRAPH_FILE_TO_DV_TYPE2 == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE_TYPE2 == g_iCurrentGraph)
  216.             {
  217.                 // if transmit graph then record on tape of the device
  218.                 DV_PutVcrMode(ED_MODE_RECORD);
  219.             } 
  220.             else
  221.             {
  222.                 //we shouldn't get here
  223.                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Undefined graph mode (maybe GRAPH_PREVIEW) in IDM_RECORD message"));
  224.             } 
  225.             break;
  226.  
  227.         case IDM_STOP :
  228.             if (GRAPH_PREVIEW != g_iCurrentGraph)
  229.             {   // for transmit & capture graphs we need stats if any
  230.                 DV_GetFinalDroppedFramesStats(GetTickCount());
  231.             } 
  232.     
  233.             // handle the timers accordingly
  234.             if (g_bUseAtnTimer)
  235.                 KillTimer(hwnd, DV_TIMER_ATN);
  236.             //if we're here, these timers were set
  237.             KillTimer(hwnd, DV_TIMER_CAPLIMIT);
  238.             KillTimer(hwnd, DV_TIMER_FRAMES);
  239.  
  240.             if (GRAPH_PREVIEW != g_iCurrentGraph)
  241.             {   // for transmit & capture graphs we need stop the graph, preview graph is running all the time
  242.                 DV_StopGraph();
  243.             } 
  244.             // Stop the transport on the device
  245.             DV_PutVcrMode(ED_MODE_STOP);
  246.             // update the toolbar 
  247.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY, MAKELONG(TBSTATE_ENABLED, 0L));
  248.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  249.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  250.             break;
  251.  
  252.         case IDM_PAUSE :
  253.             if (GRAPH_FILE_TO_DV == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE == g_iCurrentGraph ||
  254.                 GRAPH_FILE_TO_DV_TYPE2 == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE_TYPE2 == g_iCurrentGraph)
  255.             {   // transmit graph
  256.                 DV_PauseGraph();
  257.             } 
  258.             else
  259.             {   // capture or preview graph
  260.                 DV_PutVcrMode(ED_MODE_FREEZE);
  261.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  262.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  263.             } 
  264.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY, MAKELONG(TBSTATE_ENABLED, 0L));
  265.             break;    
  266.  
  267.         case IDM_FF :
  268.             // all graphs just forward the tape & update the toolbar
  269.             DV_PutVcrMode(ED_MODE_FF);
  270.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  271.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  272.             break;
  273.  
  274.         case IDM_REW :
  275.             // all graphs just rewind the tape & update the toolbar
  276.             DV_PutVcrMode(ED_MODE_REW);
  277.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  278.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  279.             break;
  280.  
  281.         case IDM_PLAY_FAST_FF :
  282.             // all graphs just forward the tape & update the toolbar
  283.             DV_PutVcrMode(ED_MODE_PLAY_FASTEST_FWD);
  284.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  285.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  286.             break;
  287.  
  288.         case IDM_PLAY_FAST_REV :
  289.             // all graphs just rewind the tape & update the toolbar
  290.             DV_PutVcrMode(ED_MODE_PLAY_FASTEST_REV);
  291.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  292.             SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  293.             break;            
  294.  
  295.         case IDM_STEP_FWD :
  296.             // all graphs just forward the tape & update the toolbar
  297.             DV_PutVcrMode(ED_MODE_STEP_FWD);
  298.             g_bUseAtnTimer = FALSE;
  299.             DV_DisplayTimecode();
  300.             break;
  301.  
  302.         case IDM_STEP_REV :
  303.             // all graphs just rewind the tape & update the toolbar
  304.             DV_PutVcrMode(ED_MODE_STEP_REV);
  305.             g_bUseAtnTimer = FALSE;
  306.             DV_DisplayTimecode();
  307.             break;
  308.  
  309.         case IDM_SEEKTIMECODE :
  310.             // ATN Seek & display on the toolbar
  311.              DV_SeekATN();
  312.              DV_DisplayTimecode();
  313.              break;
  314.  
  315.         } // switch (LOWORD(wParam))
  316.     } // switch (iMsg)
  317. }
  318.  
  319.  
  320.  
  321.  
  322. /*-------------------------------------------------------------------------
  323. Routine:        DV_WndProc
  324. Purpose:        Message Handler
  325. Arguments:    Usual
  326. Returns:        Usual
  327. Notes:          Handles Windows UI & Command Messages, Menu Messages et al
  328. ------------------------------------------------------------------------*/
  329. LRESULT CALLBACK DV_WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
  330. {
  331.     HDC         hdc ;
  332.     PAINTSTRUCT ps ;
  333.     RECT        rect;
  334.     HMENU       hmenu;
  335.     static HWND hWndTT;
  336.     
  337.     switch (iMsg)
  338.     {
  339.     case WM_CREATE :
  340.         // Initializes & loads the Controls like toolbar buttons etc
  341.         if (!DV_InitControls(hwnd, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE)))
  342.         {
  343.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("DV_InitControls failed to create one of the control windows"));
  344.         }
  345.         break;
  346.  
  347.     case WM_PAINT :
  348.         hdc = BeginPaint (hwnd, &ps) ;
  349.         GetClientRect (hwnd, &rect) ;
  350.         EndPaint (hwnd, &ps) ;
  351.         // not calling default message handler
  352.         return 0;
  353.  
  354.     case WM_SIZE:
  355.     {
  356.         RECT  rcAppWin, rcClient, rcTB;
  357.         //re-size the App window
  358.         int cxBorder = GetSystemMetrics(SM_CXBORDER);
  359.         int cyBorder = GetSystemMetrics(SM_CYBORDER);
  360.         GetWindowRect(g_hwndApp, &rcAppWin);
  361.         GetWindowRect(g_hwndTBar, &rcTB);
  362.         MoveWindow(g_hwndApp, rcAppWin.left, rcAppWin.top, g_iAppWidth, g_iAppHeight, TRUE);
  363.  
  364.         // Tell the toolbar to resize itself to fill the top of the window.
  365.         SendMessage(g_hwndTBar, TB_AUTOSIZE, 0L, 0L);
  366.  
  367.         //handle the status bar height
  368.         GetClientRect(g_hwndApp, &rcClient);
  369.         cxBorder = GetSystemMetrics(SM_CXBORDER);
  370.         cyBorder = GetSystemMetrics(SM_CYBORDER);
  371.         MoveWindow(g_hwndStatus, -cxBorder, rcClient.bottom - (g_statusHeight + cyBorder), 
  372.                    rcClient.right + (2 * cxBorder), (g_statusHeight + (2 * cyBorder)), TRUE);  
  373.         DV_StatusParts(rcClient.right);
  374.         
  375.         //re-size the video window
  376.         GetWindowRect(g_hwndTBar, &rcTB);
  377.         if (g_pVideoWindow)
  378.         {
  379.             g_pVideoWindow->SetWindowPosition(0, rcTB.bottom - rcTB.top, g_iVWWidth, g_iVWHeight);
  380.         }
  381.         break;
  382.     }
  383.  
  384.     case WM_CLOSE:
  385.         return SendMessage(hwnd, WM_DESTROY, 0,0);
  386.  
  387.     case WM_DESTROY :
  388.         // Unregister device notifications
  389.         if (g_hDevNotify != NULL)
  390.         {
  391.             ASSERT(g_pUnregisterDeviceNotification);
  392.             g_pUnregisterDeviceNotification(g_hDevNotify);
  393.             g_hDevNotify = NULL;
  394.         }
  395.         // Time to Kill All
  396.         DV_CleanUp();
  397.         hmenu = GetMenu(hwnd);
  398.         DestroyMenu(hmenu);
  399.         DestroyWindow(g_hwndTBar);
  400.         DestroyWindow(g_hwndStatus);
  401.         PostQuitMessage (0) ;
  402.         // not calling default message handler
  403.         return 0;     
  404.  
  405.     case WM_NOTIFY :
  406.     {   
  407.         //Windows Events Notify Message handler
  408.         switch (((LPNMHDR)lParam)->code)
  409.         {
  410.             case TTN_NEEDTEXT :
  411.                 LPTOOLTIPTEXT lpttt;
  412.                 TCHAR         ttBuff[128];
  413.                 lpttt = (LPTOOLTIPTEXT) lParam; 
  414.                 LoadString ((HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), (UINT) lpttt->hdr.idFrom, ttBuff, 128);
  415.                 lpttt->lpszText = ttBuff;           
  416.                 break;
  417.         } 
  418.         break;   
  419.     } 
  420.  
  421.     case WM_DEVICECHANGE:
  422.     {
  423.         // We are interested in only device arrival events
  424.         if (DBT_DEVICEARRIVAL != wParam)
  425.             break;
  426.         PDEV_BROADCAST_HDR pdbh = (PDEV_BROADCAST_HDR) lParam;
  427.         if (pdbh->dbch_devicetype != DBT_DEVTYP_DEVICEINTERFACE)
  428.             break;
  429.  
  430.         // Check for capture devices.
  431.         PDEV_BROADCAST_DEVICEINTERFACE pdbi = (PDEV_BROADCAST_DEVICEINTERFACE) lParam;
  432.         if (pdbi->dbcc_classguid != AM_KSCATEGORY_CAPTURE)
  433.             break;
  434.  
  435.         // Check for device arrival.
  436.         if (g_bDeviceFound == FALSE)
  437.         {
  438.             MessageBox(g_hwndApp, TEXT("There is a new capture device on this system..."), APPNAME, MB_OK);
  439.             DV_CleanUp();
  440.             DV_AppSetup();
  441.         }
  442.         break;
  443.     }
  444.     
  445.     case WM_FGNOTIFY :
  446.     {
  447.         //Filter Graph Events Notify Message handler
  448.         IMediaEventEx *pMe = NULL;
  449.         if(g_pGraphBuilder == NULL)
  450.             break;
  451.         else if (SUCCEEDED(g_pGraphBuilder->QueryInterface(IID_IMediaEventEx, reinterpret_cast<PVOID *>(&pMe))))
  452.         {
  453.             long event;
  454.             LONG_PTR l1, l2;
  455.             // Get the corresponding filtergraph directshow media event to handle
  456.             while (SUCCEEDED(pMe->GetEvent(&event, &l1, &l2, 0L)))
  457.             {
  458.                 switch (event)
  459.                 {
  460.                     case EC_USERABORT :
  461.                     case EC_COMPLETE :
  462.                         // filtergraph is done, time to stop the filtergraph or transport state
  463.                         SendMessage(g_hwndApp, WM_COMMAND, IDM_STOP, 0);  
  464.                         break;
  465.                     
  466.                     case EC_ERRORABORT :
  467.                         //something bad happened during capture
  468.                         MBOX(TEXT("Error during preview, capture or transmit"));
  469.                         break;
  470.                     case EC_DEVICE_LOST :
  471.                         // Check if we have lost a capture filter being used.
  472.                         // lParam2 of EC_DEVICE_LOST event == 0 indicates device removed
  473.                         // lParam2 of EC_DEVICE_LOST event == 1 indicates removed device added again
  474.                         if (l2 == 0)
  475.                         {
  476.                             IBaseFilter *pf;
  477.                             IUnknown *punk = (IUnknown *) l1;
  478.                             if (S_OK == punk->QueryInterface(IID_IBaseFilter, (void **) &pf))
  479.                             {
  480.                                 if (::IsEqualObject(g_pDVCamera, pf))
  481.                                 {
  482.                                     pMe->FreeEventParams(event, l1, l2);
  483.  
  484.                                     // handle the timers accordingly
  485.                                     if (g_bUseAtnTimer)
  486.                                         KillTimer(hwnd, DV_TIMER_ATN);
  487.                                     KillTimer(hwnd, DV_TIMER_CAPLIMIT);
  488.                                     KillTimer(hwnd, DV_TIMER_FRAMES);
  489.                                     // Cleanup the old device's filtergraph & 
  490.                                     // Search for other DV camcorders or the same DV camcorder being plugged in again, 
  491.                                     // if found set it up else exit the app
  492.                                     MBOX("DV Camcorder Device in use was removed");
  493.                                     g_bDeviceFound = FALSE;
  494.                                     DV_CleanUp();
  495.                                     DV_AppSetup();
  496.                                 }
  497.                                 pf->Release();
  498.                             }
  499.                         }
  500.                         break;
  501.  
  502.                     default :
  503.                         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("Unhandled Event Code (0x%x)"), event);
  504.                         break;
  505.                 }
  506.                 pMe->FreeEventParams(event, l1, l2);
  507.             } 
  508.             SAFE_RELEASE(pMe);
  509.         } 
  510.         SAFE_RELEASE(pMe);       
  511.         break;
  512.     }
  513.  
  514.     
  515.     case WM_COMMAND :
  516.         // Handle menu commands
  517.         hmenu = GetMenu(hwnd);
  518.         switch (LOWORD (wParam))
  519.         {
  520.             // Help Menu
  521.         case IDM_ABOUT:
  522.             DialogBox((HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), MAKEINTRESOURCE(IDD_ABOUT), hwnd, (DLGPROC)DV_AboutDlgProc);
  523.             break;
  524.  
  525.         // The File Menu 
  526.         /*  
  527.             The globals for input file and output file are TCHAR.  When compiled ANSI,
  528.             GetOpenFileName (obviously) return ANSI buffers.  DShow functions use Unicode
  529.             names exclusively, so these are converted to Unicode within the functions 
  530.             that need to use these variables (DV_Make...To... functions).
  531.         */
  532.         case IDM_SETINPUT :    //fall through
  533.         case IDM_SETOUTPUT :
  534.         case IDM_OPTIONS_SAVEGRAPH :
  535.         {
  536.             OPENFILENAME ofn = {0};
  537.             OSVERSIONINFO osi = {0};
  538.             //need to adjust the ofn struct size if we are running on win98 vs. nt5
  539.             osi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  540.             GetVersionEx(&osi);
  541.             if (osi.dwMajorVersion >=5 && osi.dwPlatformId == VER_PLATFORM_WIN32_NT)
  542.             {
  543.                 ofn.lStructSize = sizeof (OPENFILENAME);
  544.             } 
  545.             else
  546.             {
  547.                 ofn.lStructSize = sizeof(OPENFILENAME);
  548.             }   
  549.             
  550.             ofn.hwndOwner = g_hwndApp;
  551.             ofn.nMaxFile = _MAX_PATH;
  552.             if (IDM_OPTIONS_SAVEGRAPH == LOWORD (wParam))
  553.             {
  554.                 ofn.lpstrFilter = TEXT("Filter Graph\0*.grf\0\0");
  555.                 ofn.lpstrTitle = TEXT("Set FilterGraph File Name");
  556.                 ofn.lpstrFile = g_FilterGraphFileName;
  557.             } 
  558.             else if (IDM_SETOUTPUT == LOWORD (wParam))
  559.             {
  560.                 ofn.lpstrFilter = TEXT("Microsoft AVI\0*.avi\0\0");
  561.                 ofn.lpstrTitle = TEXT("Set output File Name");
  562.                 ofn.lpstrFile = g_OutputFileName;
  563.             } 
  564.             else
  565.             {
  566.                 ofn.lpstrFilter = TEXT("Microsoft AVI\0*.avi\0\0");
  567.                 ofn.lpstrTitle = TEXT("Set input File Name");
  568.                 ofn.lpstrFile = g_InputFileName;
  569.             } 
  570.  
  571.             if (GetOpenFileName(&ofn))
  572.             {
  573.                 if (IDM_OPTIONS_SAVEGRAPH == LOWORD (wParam))
  574.                 {
  575.                     lstrcpy(g_FilterGraphFileName, ofn.lpstrFile);
  576.                     // Save the current built filter graph to a *.grf file
  577.                     DV_SaveGraph(g_FilterGraphFileName);
  578.                 } 
  579.                 else if (IDM_SETOUTPUT == LOWORD (wParam))
  580.                 {
  581.                     lstrcpy(g_OutputFileName, ofn.lpstrFile);
  582.                 } 
  583.                 else
  584.                 {
  585.                     lstrcpy(g_InputFileName, ofn.lpstrFile);
  586.                 } 
  587.             }
  588.             break;    
  589.         } 
  590.  
  591.         case IDM_CAPSIZE:
  592.             DialogBox((HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), MAKEINTRESOURCE(IDD_DIALOG_CAPSIZE), hwnd, (DLGPROC)DV_CapSizeDlgProc);
  593.             break;
  594.  
  595.         case IDM_EXIT :
  596.             return SendMessage(hwnd, WM_DESTROY, 0,0);
  597.  
  598.         // Graph Mode Menu
  599.         //Change the Current Graph Mode
  600.         case IDM_PREVIEW :
  601.         case IDM_FILETODV :
  602.         case IDM_FILETODV_NOPRE :
  603.         case IDM_DVTOFILE :
  604.         case IDM_DVTOFILE_NOPRE :
  605.         case IDM_FILETODV_TYPE2 :
  606.         case IDM_FILETODV_NOPRE_TYPE2 :
  607.         case IDM_DVTOFILE_TYPE2 :
  608.         case IDM_DVTOFILE_NOPRE_TYPE2 :
  609.             DV_GraphModeCommand_WndProc (hwnd, iMsg, wParam, lParam);
  610.             break;
  611.  
  612.         // Toolbar Button Commands
  613.         // Transport State & Graph State Control
  614.         case IDM_PLAY :
  615.         case IDM_RECORD :
  616.         case IDM_STOP :
  617.         case IDM_PAUSE :
  618.         case IDM_FF :
  619.         case IDM_REW :
  620.         case IDM_PLAY_FAST_FF :
  621.         case IDM_PLAY_FAST_REV :
  622.         case IDM_STEP_FWD :
  623.         case IDM_STEP_REV :
  624.         case IDM_SEEKTIMECODE :
  625.             DV_TransportCommand_WndProc(hwnd, iMsg, wParam, lParam);
  626.             break;
  627.  
  628.         // The Options Menu
  629.         case IDM_DECODESIZE :
  630.             DialogBox((HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), MAKEINTRESOURCE(IDD_DIALOG_DECODESIZE), hwnd, (DLGPROC)DV_ChangeDecodeSizeProc);
  631.             break;
  632.             
  633.         case IDM_CHECKTAPE :
  634.             if (S_OK != DV_GetTapeInfo())
  635.             {
  636.                 MBOX(TEXT("Tape is not inserted, or has an improper format.\nReinsert the tape and select Options - Check Tape again"));
  637.             } 
  638.             break;
  639.  
  640.         case IDM_REFRESHMODE :
  641.             DV_RefreshMode();
  642.             break;
  643.                 
  644.         // Log Menu :: Set logging Priority & level 
  645.         case IDM_LEVEL_SUCCINCT :
  646.              CheckMenuItem(hmenu, IDM_LEVEL_SUCCINCT, MF_CHECKED);
  647.              CheckMenuItem(hmenu, IDM_LEVEL_MEDIUM, MF_UNCHECKED);
  648.              CheckMenuItem(hmenu, IDM_LEVEL_VERBOSE, MF_UNCHECKED);
  649.              g_iLogLevel = LOG_LEVEL_SUCCINCT;
  650.              break;
  651.         case IDM_LEVEL_MEDIUM :
  652.              CheckMenuItem(hmenu, IDM_LEVEL_SUCCINCT, MF_UNCHECKED);
  653.              CheckMenuItem(hmenu, IDM_LEVEL_MEDIUM, MF_CHECKED);
  654.              CheckMenuItem(hmenu, IDM_LEVEL_VERBOSE, MF_UNCHECKED);
  655.              g_iLogLevel = LOG_LEVEL_MEDIUM;
  656.              break;
  657.         case IDM_LEVEL_VERBOSE :
  658.              CheckMenuItem(hmenu, IDM_LEVEL_SUCCINCT, MF_UNCHECKED);
  659.              CheckMenuItem(hmenu, IDM_LEVEL_MEDIUM, MF_UNCHECKED);
  660.              CheckMenuItem(hmenu, IDM_LEVEL_VERBOSE, MF_CHECKED);
  661.              g_iLogLevel = LOG_LEVEL_VERBOSE;
  662.              break;
  663.  
  664.         case IDM_PRIORITY_ERROR :
  665.              CheckMenuItem(hmenu, IDM_PRIORITY_ERROR, MF_CHECKED);
  666.              CheckMenuItem(hmenu, IDM_PRIORITY_WARN, MF_UNCHECKED);
  667.              CheckMenuItem(hmenu, IDM_PRIORITY_INFO, MF_UNCHECKED);
  668.              g_iLogPriority = LOG_PRIORITY_ERROR;
  669.              break;
  670.         case IDM_PRIORITY_WARN :
  671.              CheckMenuItem(hmenu, IDM_PRIORITY_ERROR, MF_UNCHECKED);
  672.              CheckMenuItem(hmenu, IDM_PRIORITY_WARN, MF_CHECKED);
  673.              CheckMenuItem(hmenu, IDM_PRIORITY_INFO, MF_UNCHECKED);
  674.              g_iLogPriority = LOG_PRIORITY_WARN;
  675.              break;
  676.         case IDM_PRIORITY_INFO :
  677.              CheckMenuItem(hmenu, IDM_PRIORITY_ERROR, MF_UNCHECKED);
  678.              CheckMenuItem(hmenu, IDM_PRIORITY_WARN, MF_UNCHECKED);
  679.              CheckMenuItem(hmenu, IDM_PRIORITY_INFO, MF_CHECKED);
  680.              g_iLogPriority = LOG_PRIORITY_INFO;
  681.              break;
  682.  
  683.         } // switch (LOWORD(wParam))
  684.         
  685.                
  686.     } // switch (iMsg)
  687.     return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
  688. }
  689.  
  690.  
  691. /*-------------------------------------------------------------------------
  692. Routine:        DV_GraphModeCommand_WndProc
  693. Purpose:        Message Handler for Graph Mode menu items
  694. Arguments:    Usual message processing parameters
  695. Returns:        Usual
  696. Notes:          Builds the various kinds of Graph types preview/capture/transmit
  697. ------------------------------------------------------------------------*/
  698. void CALLBACK DV_GraphModeCommand_WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
  699. {
  700.     HMENU       hmenu;    
  701.     switch (iMsg)
  702.     {
  703.     case WM_COMMAND :
  704.         hmenu = GetMenu(hwnd);
  705.         switch (LOWORD (wParam))
  706.         {   
  707.         case IDM_PREVIEW :
  708.             // Call the Special DV Graph Builder Method 
  709.             if (DV_MakeSpecialGraph(GRAPH_PREVIEW))
  710.             {
  711.                 // update globals, log, toolbar, menu items
  712.                 g_iCurrentGraph = GRAPH_PREVIEW;
  713.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built Preview Graph"));
  714.  
  715.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  716.                 //re-enable everything else
  717.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  718.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_ENABLED, 0L));
  719.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  720.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  721.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  722.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  723.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_ENABLED, 0L));
  724.                 
  725.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_CHECKED);
  726.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  727.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  728.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  729.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  730.  
  731.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  732.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  733.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  734.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  735.             } 
  736.             break;
  737.  
  738.         // Type 1 file (transmit & playback)    
  739.         case IDM_FILETODV :
  740.             if (DV_MakeSpecialGraph(GRAPH_FILE_TO_DV))
  741.             {
  742.                 // update globals, log, toolbar, menu items
  743.                 g_iCurrentGraph = GRAPH_FILE_TO_DV;
  744.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built File to DV Graph (Type1)"));
  745.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  746.  
  747.                 //disable everything except for play, pause, and stop
  748.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  749.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  750.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  751.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  752.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  753.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  754.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  755.  
  756.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  757.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_CHECKED);
  758.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  759.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  760.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  761.  
  762.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  763.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  764.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  765.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  766.             } 
  767.             break;
  768.  
  769.         // Type 1 file (transmit)   
  770.         case IDM_FILETODV_NOPRE :
  771.             if (DV_MakeSpecialGraph(GRAPH_FILE_TO_DV_NOPRE))
  772.             {
  773.                 // update globals, log, toolbar, menu items
  774.                 g_iCurrentGraph = GRAPH_FILE_TO_DV_NOPRE;
  775.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built File to DV Graph (Type1) without Preview"));
  776.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  777.  
  778.                 //disable everything except for play, pause, and stop
  779.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  780.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  781.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  782.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  783.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  784.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  785.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  786.  
  787.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  788.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  789.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  790.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_CHECKED);
  791.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  792.  
  793.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  794.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  795.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  796.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  797.  
  798.             } 
  799.             break;
  800.             
  801.         // Type 1 file (capture & preview)  
  802.         case IDM_DVTOFILE :
  803.             if (DV_MakeSpecialGraph(GRAPH_DV_TO_FILE))
  804.             {
  805.                 // update globals, log, toolbar, menu items
  806.                 g_iCurrentGraph = GRAPH_DV_TO_FILE;
  807.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built DV to File Graph (Type1)"));
  808.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  809.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  810.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  811.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_CHECKED);
  812.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  813.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  814.  
  815.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  816.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  817.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  818.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  819.                 //re-enable everything 
  820.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  821.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_ENABLED, 0L));
  822.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  823.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  824.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  825.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  826.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_ENABLED, 0L));
  827.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  828.  
  829.             } 
  830.             break;
  831.  
  832.         // Type 1 file (capture)    
  833.         case IDM_DVTOFILE_NOPRE :
  834.             if (DV_MakeSpecialGraph(GRAPH_DV_TO_FILE_NOPRE))
  835.             {
  836.                 // update globals, log, toolbar, menu items
  837.                 g_iCurrentGraph = GRAPH_DV_TO_FILE_NOPRE;
  838.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built DV to File Graph (Type1) without Preview"));
  839.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  840.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  841.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  842.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  843.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  844.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_CHECKED);
  845.  
  846.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  847.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  848.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  849.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  850.  
  851.                 //re-enable everything 
  852.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  853.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_ENABLED, 0L));
  854.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  855.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  856.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  857.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  858.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_ENABLED, 0L));
  859.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  860.             } 
  861.             break;
  862.  
  863.         // Type 2 File (transmit & playback)
  864.         case IDM_FILETODV_TYPE2 :
  865.             if (DV_MakeSpecialGraph(GRAPH_FILE_TO_DV_TYPE2))
  866.             {
  867.                 // update globals, log, toolbar, menu items
  868.                 g_iCurrentGraph = GRAPH_FILE_TO_DV_TYPE2;
  869.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built File to DV Graph (Type2)"));
  870.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  871.  
  872.                 //disable everything except for play, pause, and stop
  873.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  874.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  875.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  876.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  877.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  878.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  879.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  880.  
  881.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  882.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  883.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  884.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  885.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  886.  
  887.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_CHECKED);
  888.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  889.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  890.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  891.             } 
  892.             break;
  893.  
  894.         // Type 2 File (transmit)
  895.         case IDM_FILETODV_NOPRE_TYPE2 :
  896.             if (DV_MakeSpecialGraph(GRAPH_FILE_TO_DV_NOPRE_TYPE2))
  897.             {
  898.                 // update globals, log, toolbar, menu items
  899.                 g_iCurrentGraph = GRAPH_FILE_TO_DV_NOPRE_TYPE2;
  900.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built File to DV Graph (Type2) without Preview"));
  901.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  902.  
  903.                 //disable everything except for play, pause, and stop
  904.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  905.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  906.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  907.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  908.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  909.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  910.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  911.  
  912.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  913.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  914.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  915.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  916.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  917.  
  918.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  919.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_CHECKED);
  920.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  921.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);               
  922.             } 
  923.             break;
  924.             
  925.         // Type 2 File (capture & preview)
  926.         case IDM_DVTOFILE_TYPE2 :
  927.             if (DV_MakeSpecialGraph(GRAPH_DV_TO_FILE_TYPE2))
  928.             {
  929.                 // update globals, log, toolbar, menu items
  930.                 g_iCurrentGraph = GRAPH_DV_TO_FILE_TYPE2;
  931.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built DV to File Graph (Type2)"));
  932.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  933.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  934.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  935.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  936.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  937.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  938.  
  939.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  940.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  941.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_CHECKED);
  942.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_UNCHECKED);
  943.                 //re-enable everything 
  944.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  945.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_ENABLED, 0L));
  946.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  947.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  948.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  949.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  950.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_ENABLED, 0L));
  951.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  952.  
  953.             } 
  954.             break;
  955.  
  956.         // Type 2 File (capture)
  957.         case IDM_DVTOFILE_NOPRE_TYPE2 :
  958.             if (DV_MakeSpecialGraph(GRAPH_DV_TO_FILE_NOPRE_TYPE2))
  959.             {
  960.                 // update globals, log, toolbar, menu items
  961.                 g_iCurrentGraph = GRAPH_DV_TO_FILE_NOPRE_TYPE2;
  962.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built DV to File Graph (Type2) without Preview"));
  963.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  964.                 CheckMenuItem(hmenu, IDM_PREVIEW, MF_UNCHECKED);
  965.                 CheckMenuItem(hmenu, IDM_FILETODV, MF_UNCHECKED);
  966.                 CheckMenuItem(hmenu, IDM_DVTOFILE, MF_UNCHECKED);
  967.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_UNCHECKED);
  968.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_UNCHECKED);
  969.  
  970.                 CheckMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_UNCHECKED);
  971.                 CheckMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_UNCHECKED);
  972.                 CheckMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_UNCHECKED);
  973.                 CheckMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_CHECKED);
  974.  
  975.                 //re-enable everything 
  976.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  977.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_ENABLED, 0L));
  978.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  979.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  980.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  981.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  982.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_ENABLED, 0L));
  983.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_ENABLED, 0L));
  984.  
  985.             } 
  986.             break;
  987.         } // switch (LOWORD(wParam))
  988.     } // switch (iMsg)
  989. }
  990.  
  991. /*-------------------------------------------------------------------------
  992. Routine:        DV_AppSetup
  993. Purpose:        look for a DV device, initialize it, get its subunit mode, Create the filtergraph and instantiate the filters
  994. Arguments:    None
  995. Returns:        None
  996. Notes:          
  997. ------------------------------------------------------------------------*/
  998. void DV_AppSetup(void)
  999. {
  1000.     
  1001.     // COM initialization
  1002.     CoInitialize(NULL);
  1003.  
  1004.     HMENU hmenu = GetMenu(g_hwndApp);   
  1005.     /*
  1006.         look for a DV device and initialize it,
  1007.         or show an error if one does not exist
  1008.     */  
  1009.     if (!DV_InitDevice())
  1010.     {
  1011.         g_bDeviceFound = FALSE;
  1012.         int iOption = MessageBox(g_hwndApp, TEXT("There are no DV Camcorder devices on this system\n\nDo you want to exit the app?"), APPNAME, MB_YESNO);
  1013.         if(iOption == IDYES) 
  1014.             SendMessage(g_hwndApp, WM_DESTROY, 0,0);
  1015.         else
  1016.         {
  1017.             DV_CleanUp();
  1018.             ShowWindow(g_hwndTBar, SW_HIDE);
  1019.  
  1020.             EnableMenuItem(hmenu, IDM_REFRESHMODE, MF_GRAYED);
  1021.             EnableMenuItem(hmenu, IDM_CHECKTAPE, MF_GRAYED);
  1022.             EnableMenuItem(hmenu, IDM_DECODESIZE, MF_GRAYED);
  1023.             EnableMenuItem(hmenu, IDM_PREVIEW, MF_GRAYED);
  1024.  
  1025.             EnableMenuItem(hmenu, IDM_DVTOFILE, MF_GRAYED);
  1026.             EnableMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_GRAYED);
  1027.             EnableMenuItem(hmenu, IDM_FILETODV, MF_GRAYED);
  1028.             EnableMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_GRAYED);
  1029.  
  1030.             EnableMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_GRAYED);
  1031.             EnableMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_GRAYED);
  1032.             EnableMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_GRAYED);
  1033.             EnableMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_GRAYED);
  1034.         }
  1035.     }
  1036.     else
  1037.     {
  1038.             g_bDeviceFound = TRUE;
  1039.             ShowWindow(g_hwndTBar, SW_SHOWNORMAL);
  1040.             EnableMenuItem(hmenu, IDM_REFRESHMODE, MF_ENABLED);
  1041.             EnableMenuItem(hmenu, IDM_CHECKTAPE, MF_ENABLED);
  1042.             EnableMenuItem(hmenu, IDM_DECODESIZE, MF_ENABLED);
  1043.             EnableMenuItem(hmenu, IDM_PREVIEW, MF_ENABLED);
  1044.  
  1045.             EnableMenuItem(hmenu, IDM_DVTOFILE, MF_ENABLED);
  1046.             EnableMenuItem(hmenu, IDM_DVTOFILE_NOPRE, MF_ENABLED);
  1047.             EnableMenuItem(hmenu, IDM_FILETODV, MF_ENABLED);
  1048.             EnableMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_ENABLED);
  1049.  
  1050.             EnableMenuItem(hmenu, IDM_DVTOFILE_TYPE2, MF_ENABLED);
  1051.             EnableMenuItem(hmenu, IDM_DVTOFILE_NOPRE_TYPE2, MF_ENABLED);
  1052.             EnableMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_ENABLED);
  1053.             EnableMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_ENABLED);
  1054.  
  1055.         //if we are here, all of our interfaces should be valid
  1056.         ASSERT(g_pBuilder);
  1057.         ASSERT(g_pGraphBuilder);
  1058.         ASSERT(g_pDVCamera);
  1059.  
  1060.         //get directshow interfaces for DV
  1061.         g_pBuilder->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, g_pDVCamera, IID_IAMExtTransport, reinterpret_cast<PVOID*>(&g_pExtTrans));
  1062.         g_pBuilder->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, g_pDVCamera, IID_IAMTimecodeReader, reinterpret_cast<PVOID*>(&g_pTimeReader));
  1063.  
  1064.         //determine if we are in camera mode or vcr mode and disable unavailable menu items
  1065.         //  Use GetDVMode to *not* use AVC commands
  1066.  
  1067.         switch (DV_GetDVMode())
  1068.         {
  1069.             case CameraMode :          
  1070.                 EnableMenuItem(hmenu, IDM_FILETODV, MF_GRAYED);
  1071.                 EnableMenuItem(hmenu, IDM_FILETODV_NOPRE, MF_GRAYED);
  1072.                 EnableMenuItem(hmenu, IDM_FILETODV_TYPE2, MF_GRAYED);
  1073.                 EnableMenuItem(hmenu, IDM_FILETODV_NOPRE_TYPE2, MF_GRAYED);
  1074.                 EnableMenuItem(hmenu, IDM_CHECKTAPE, MF_GRAYED);
  1075.                 DV_StatusText(TEXT("Camera Mode"), 2);
  1076.                 break;                
  1077.  
  1078.             case VcrMode :
  1079.                //check information about the tape
  1080.                 if (S_OK != DV_GetTapeInfo())
  1081.                 {
  1082.                     MBOX(TEXT("Tape is not inserted, or has an improper format.\nReinsert the tape and select Options - Check Tape"));
  1083.                 } 
  1084.                 break;
  1085.  
  1086.             case UnknownMode :
  1087.                 MBOX(TEXT("Cannot determine camera / Vcr mode"));
  1088.                 DV_StatusText(TEXT("Unknown Mode"), 2);
  1089.                 break;
  1090.  
  1091.             default :
  1092.                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Bad return value from DV_GetDVMode"));
  1093.                 break;
  1094.         } 
  1095.         
  1096.         // initialize the video window
  1097.         if (!DV_InitWindow())
  1098.         {
  1099.             MBOX(TEXT("Could not initialize video window"));
  1100.             SendMessage(g_hwndApp, WM_DESTROY, 0,0);
  1101.         } 
  1102.         else
  1103.         {
  1104.             //If we've gotten this far, all of these components should be available
  1105.             //DV Splitter, DV Muxer, DV Codec is part of QDV
  1106.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_DVSplitter, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pDVSplitter)));
  1107.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_DVMux, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pDVMux)));
  1108.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_DVVideoCodec, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pDVCodec)));
  1109.             // Other filters to help in building the graphs
  1110.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_AviSplitter, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pAviSplitter)));
  1111.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_SmartTee, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pSmartTee)));
  1112.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_InfTee, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pInfTee)));
  1113.             EXECUTE_ASSERT(S_OK == CoCreateInstance(CLSID_VideoRenderer, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pVideoRenderer)));
  1114.             // The user may not have a sound card installed , so if this fails, we just won't do sound.
  1115.             CoCreateInstance(CLSID_DSoundRender, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pDSound));
  1116.  
  1117.             IMediaEventEx *pMe = NULL;
  1118.             if (SUCCEEDED(g_pGraphBuilder->QueryInterface(IID_IMediaEventEx, reinterpret_cast<PVOID *>(&pMe))))
  1119.             {
  1120.                 pMe->SetNotifyWindow((LONG_PTR) g_hwndApp, WM_FGNOTIFY, 0);
  1121.                 SAFE_RELEASE(pMe);
  1122.             } 
  1123.  
  1124.             SetWindowText(g_hwndApp, DV_APPTITLE);
  1125.             DV_StatusText(g_DeviceName, 0);
  1126.         } 
  1127.     }
  1128.  
  1129. }
  1130.  
  1131.  
  1132. /*-------------------------------------------------------------------------
  1133. Routine:        DV_InitControls
  1134. Purpose:        Initializer for app window controls (toolbars, edit controls, etc.)
  1135. Arguments:    window handle and hinstance
  1136. Returns:        FALSE if creation of any of the controls fails.
  1137. Notes:          
  1138. ------------------------------------------------------------------------*/
  1139. BOOL DV_InitControls(HWND hwnd, HINSTANCE hInst)
  1140. {
  1141.     HWND hwndEdit1 = NULL;
  1142.     HWND hwndEdit2 = NULL;
  1143.     HWND hwndEdit3 = NULL;
  1144.     HWND hwndEdit4 = NULL;
  1145.     HWND hwndTCCheck = NULL;
  1146.  
  1147.     RECT rect = {0};
  1148.         
  1149.     InitCommonControls();
  1150.     // create status bar windows
  1151.     g_hwndStatus = CreateWindowEx( 0,
  1152.                                    STATUSCLASSNAME,
  1153.                                    TEXT(""),
  1154.                                    WS_CHILD | WS_BORDER | WS_VISIBLE | WS_CLIPSIBLINGS,
  1155.                                    -100, -100,
  1156.                                    10, 10,
  1157.                                    hwnd,
  1158.                                    HMENU(IDB_STATUS),
  1159.                                    hInst,
  1160.                                    NULL);
  1161.     SendMessage(g_hwndStatus, SB_GETRECT, 0, (LPARAM)(LPRECT)&rect);          
  1162.     g_statusHeight = rect.bottom;
  1163.     //Set the initial size for the status bar parts.  The WM_SIZE handler will take care of it from here
  1164.     DV_StatusParts(g_iAppWidth);
  1165.  
  1166.     // create toolbar window
  1167.     g_hwndTBar = CreateToolbarEx(hwnd, 
  1168.                                    WS_CHILD | WS_VISIBLE | WS_BORDER | TBSTYLE_TOOLTIPS, 
  1169.                                    ID_TOOLBAR, 
  1170.                                    10, 
  1171.                                    hInst, 
  1172.                                    IDB_TOOLBAR, 
  1173.                                    g_rgTbButtons, 
  1174.                                    sizeof(g_rgTbButtons) / sizeof(TBBUTTON), 
  1175.                                    16,16,16,16, 
  1176.                                    sizeof(TBBUTTON)); 
  1177.  
  1178.     SendMessage(g_hwndTBar, TB_GETRECT, IDM_SEEKTIMECODE, (LPARAM)&rect);
  1179.  
  1180.     if (!rect.right)
  1181.     {
  1182.         DV_LogOut(LOG_PRIORITY_WARN, LOG_LEVEL_MEDIUM, TEXT("Could not get rect of Seek Time code button"));
  1183.         rect.right = 350;
  1184.     } 
  1185.     // create timecode text boxes on the toolbar            
  1186.     hwndEdit1 = CreateWindow(TEXT("edit"), TEXT("00"), WS_CHILD | WS_BORDER | WS_VISIBLE | WS_TABSTOP | ES_NUMBER, 
  1187.                     rect.right + 6, 4, 22, 18, g_hwndTBar, (HMENU)IDC_EDIT_HOUR, (HINSTANCE) hInst, NULL);
  1188.     
  1189.     hwndEdit2 = CreateWindow(TEXT("edit"), TEXT("00"), WS_CHILD | WS_BORDER | WS_VISIBLE | WS_TABSTOP | ES_NUMBER,  
  1190.                     rect.right + 30, 4, 22, 18, g_hwndTBar, (HMENU)IDC_EDIT_MINUTE, (HINSTANCE) hInst, NULL);
  1191.     
  1192.     hwndEdit3 = CreateWindow(TEXT("edit"), TEXT("00"), WS_CHILD | WS_BORDER | WS_VISIBLE | WS_TABSTOP | ES_NUMBER, 
  1193.                     rect.right + 54, 4, 22, 18, g_hwndTBar, (HMENU)IDC_EDIT_SECOND, (HINSTANCE) hInst, NULL);
  1194.  
  1195.     hwndEdit4 = CreateWindow(TEXT("edit"), TEXT("00"), WS_CHILD | WS_BORDER | WS_VISIBLE | WS_TABSTOP | ES_NUMBER, 
  1196.                     rect.right + 78, 4, 22, 18, g_hwndTBar, (HMENU)IDC_EDIT_FRAME, (HINSTANCE) hInst, NULL);
  1197.  
  1198.     hwndTCCheck = CreateWindow(TEXT("button"), TEXT("Display Timecodes"), WS_CHILD | BS_AUTOCHECKBOX | WS_VISIBLE | WS_TABSTOP, 
  1199.                     rect.right + 106, 5, 150, 18, g_hwndTBar, (HMENU)IDC_TCCHECKBOX, (HINSTANCE) hInst, NULL); 
  1200.     Button_SetCheck (hwndTCCheck, BST_CHECKED) ;                    
  1201.  
  1202.     //finally, resize the main window so it maintains the proper height despite the toolbar and status bar
  1203.     MoveWindow(g_hwndApp, CW_USEDEFAULT, CW_USEDEFAULT, 
  1204.                g_iAppWidth, g_iAppHeight + (rect.bottom - rect.top) + 
  1205.                (g_statusHeight + (2 * GetSystemMetrics(SM_CYBORDER))), TRUE);
  1206.     
  1207.     return (!( !hwndEdit1) || (!hwndEdit2) || (!hwndEdit3) || (!hwndEdit4) || (!hwndTCCheck) || (!g_hwndStatus));
  1208.  
  1209. } 
  1210.  
  1211.  
  1212. /*-------------------------------------------------------------------------
  1213. Routine:        DV_InitDevice
  1214. Purpose:        Enumerates all video devices, and determines if it is a DV device.  
  1215.                     We'll do this by querying for an interface specific to DV - in this
  1216.                     case, IAMExtDevice.
  1217. Arguments:    None
  1218. Returns:        TRUE if a DV device is found
  1219. Notes:          Will this solution work all the time. No, but then all other solutions are equally unreliable 
  1220.                     like comparing friendlyname or signal mode or device type on the transport. 
  1221.                     May be the mediatype of the Source filter should solve the problem, but then maybe not.
  1222. ------------------------------------------------------------------------*/
  1223. BOOL DV_InitDevice(void)
  1224. {
  1225.     BOOL bStatus = FALSE;
  1226.     HRESULT hr;
  1227.     UINT uIndex = 0;
  1228.     ICreateDevEnum *pCreateDevEnum = NULL;
  1229.     // Before we can QI for IAMExtDevice, we need to build a graph and add our filter.
  1230.     
  1231.     // Create Device Enumerator
  1232.     hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, reinterpret_cast<PVOID *>(&pCreateDevEnum));
  1233.     if (SUCCEEDED(hr) )
  1234.     {
  1235.         // get the enumerator for videoinput devices
  1236.         IEnumMoniker *pEm;
  1237.         hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEm, 0);
  1238.         if (SUCCEEDED(hr) && pEm)
  1239.         {
  1240.             pCreateDevEnum->Release();
  1241.             {
  1242.                 pEm->Reset();
  1243.                 ULONG cFetched;
  1244.                 IMoniker *pM;
  1245.                 //loop while we can still enumerate, the enumeration succeeds, and while we have'nt yet found a dv camera
  1246.                 while ( S_OK == (hr = pEm->Next(1, &pM, &cFetched)) && FALSE == bStatus )
  1247.                 {
  1248.                     // getting the propert page to get the device name
  1249.                     IPropertyBag *pBag;
  1250.                     hr = pM->BindToStorage(0, 0, IID_IPropertyBag, reinterpret_cast<PVOID *>(&pBag));
  1251.                     if ( SUCCEEDED(hr) )
  1252.                     {
  1253.                         VARIANT var;
  1254.                         var.vt = VT_BSTR;
  1255.                         hr = pBag->Read(L"FriendlyName", &var, NULL);
  1256.                         if ( SUCCEEDED(hr) )
  1257.                         {
  1258.     //here, we'll save the device name
  1259. #ifndef UNICODE
  1260.                             WideCharToMultiByte(CP_ACP, 0, var.bstrVal, -1, g_DeviceName, DEVICENAME_BUFSIZE,  NULL, NULL);
  1261. #else
  1262.                             lstrcpyW(g_DeviceName, var.bstrVal);
  1263. #endif //UNICODE                        
  1264.                             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Device Found:\t%s"), g_DeviceName);
  1265.                             SysFreeString(var.bstrVal);
  1266.                             // Get the filter of video input device
  1267.                             hr = pM->BindToObject(0, 0, IID_IBaseFilter, reinterpret_cast<PVOID *>(&g_pDVCamera));
  1268.                             if ( g_pDVCamera == NULL )
  1269.                             {
  1270.                                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Error %x: Cannot create video capture filter"), hr);
  1271.                                 return FALSE;
  1272.                             }
  1273.                             else
  1274.                             {   // get the graph builder & capture graph builder to QI
  1275.                                 if (DV_GetGraphBuilder())
  1276.                                 {
  1277.                                     hr = CoCreateInstance((REFCLSID)CLSID_CaptureGraphBuilder2,
  1278.                                                 NULL, CLSCTX_INPROC, (REFIID)IID_ICaptureGraphBuilder2,
  1279.                                                 reinterpret_cast<PVOID *>(&g_pBuilder));
  1280.  
  1281.                                     if (SUCCEEDED(hr))
  1282.                                     {
  1283.                                         hr = g_pBuilder->SetFiltergraph(g_pGraphBuilder);
  1284.                                         if (SUCCEEDED(hr))
  1285.                                         {
  1286.                                             //add the DV cam to the graph
  1287.                                             hr = g_pGraphBuilder->AddFilter(g_pDVCamera, var.bstrVal);
  1288.                                             if (SUCCEEDED(hr))
  1289.                                             {   // QI for IAMExtDevice
  1290.                                                 hr = g_pBuilder->FindInterface(&PIN_CATEGORY_CAPTURE,
  1291.                                                                   &MEDIATYPE_Video,  
  1292.                                                                   g_pDVCamera,IID_IAMExtDevice, 
  1293.                                                                   reinterpret_cast<PVOID*>(&g_pExtDev));
  1294.                                                 if (SUCCEEDED(hr))
  1295.                                                 {
  1296.                                                     //we have a DV camera
  1297.                                                     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("We Have a DV camera"));
  1298.                                                     bStatus = TRUE;
  1299.                                                 } 
  1300.                                                 else
  1301.                                                 {
  1302.                                                     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("This is not a DV camera"));
  1303.                                                     //release our interfaces
  1304.                                                     SAFE_RELEASE(g_pGraphBuilder);
  1305.                                                     SAFE_RELEASE(g_pBuilder);
  1306.                                                     SAFE_RELEASE(g_pDVCamera);
  1307.                                                 }                                                               
  1308.                                             } 
  1309.                                             else
  1310.                                             {
  1311.                                                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("AddFilter failed hr. = 0x%x"), hr);
  1312.                                             }
  1313.                                         } 
  1314.                                         else
  1315.                                         {
  1316.                                             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("SetFilterGraph failed. hr = 0x%x"), hr);
  1317.                                         }
  1318.                                     }
  1319.                                     else
  1320.                                     {
  1321.                                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("CoCreateInstance failed (ICaptureGraphbuilder2). hr = 0x%x"), hr);
  1322.                                     } 
  1323.                                 }
  1324.                                 else
  1325.                                 {
  1326.                                     DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("DV_GetGraphBuilder failed"));
  1327.                                 } 
  1328.                                 
  1329.                             } //end g_pDVCamera == NULL
  1330.                             
  1331.                         } //end SUCCEEDED(hr)
  1332.                         pBag->Release();
  1333.                     }
  1334.                     pM->Release();
  1335.                     uIndex++;
  1336.                 }
  1337.                 pEm->Release();
  1338.             }
  1339.         }
  1340.         else
  1341.         {
  1342.             // no interesting devices
  1343.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("CreateClassEnumerator failed or Enumerator was not initialized. hr = 0x%c"), hr);
  1344.             MBOX(TEXT("There are no video devices installed"));
  1345.         } 
  1346.     }
  1347.     return bStatus;
  1348. } 
  1349.  
  1350.  
  1351. /*-------------------------------------------------------------------------
  1352. Routine:        DV_GetGraphBuilder
  1353. Purpose:        wrapper to get IGraphBuilder interface pointer
  1354. Arguments:    None
  1355. Returns:        TRUE if successful
  1356. Notes:          
  1357. ------------------------------------------------------------------------*/
  1358. BOOL DV_GetGraphBuilder(void)
  1359. {
  1360.     //if we have one, release it, and make a new one
  1361.     if (g_pGraphBuilder)
  1362.     {
  1363.         g_pGraphBuilder->Release();
  1364.         g_pGraphBuilder = NULL;
  1365.     } 
  1366.     HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC, IID_IGraphBuilder, reinterpret_cast<PVOID *>(&g_pGraphBuilder));
  1367.     return (SUCCEEDED(hr)) ? TRUE : FALSE;
  1368. }
  1369.  
  1370. /*-------------------------------------------------------------------------
  1371. Routine:        DV_InitWindow
  1372. Purpose:       Window initialization routine.  This does the following:
  1373.                     - Renders the VideoStream
  1374.                     - makes the app window the output window
  1375.                     - Plays the graph (preview)
  1376. Arguments:    None
  1377. Returns:        TRUE if Everything works - FALSE otherwise
  1378. Notes:          
  1379. ------------------------------------------------------------------------*/
  1380. BOOL DV_InitWindow(void)
  1381. {
  1382.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Entering DV_InitWindow"));
  1383.     BOOL        bStatus = FALSE;
  1384.     HRESULT     hr;
  1385.     // QI for IAMStreamConfig to make sure
  1386.     hr = g_pBuilder->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, g_pDVCamera, IID_IAMStreamConfig, reinterpret_cast<PVOID *>(&g_pStreamConf));
  1387.     if (SUCCEEDED(hr))
  1388.     {
  1389.         AM_MEDIA_TYPE *pmt;
  1390.         hr = g_pStreamConf->GetFormat(&pmt); 
  1391.         if (SUCCEEDED(hr))
  1392.         {
  1393.             DeleteMediaType(pmt);
  1394.             // build the default preview graph
  1395.             bStatus = DV_MakeSpecialGraph(GRAPH_PREVIEW);            
  1396.             if (bStatus)
  1397.             {
  1398.                 // update globals, log, toolbar
  1399.                 g_iCurrentGraph = GRAPH_PREVIEW;
  1400.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Built Preview Graph"));
  1401.  
  1402.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_RECORD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
  1403.                 //re-enable everything else
  1404.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  1405.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_REW, MAKELONG(TBSTATE_ENABLED, 0L));
  1406.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_REV, MAKELONG(TBSTATE_ENABLED, 0L));
  1407.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_PLAY_FAST_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  1408.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_FF, MAKELONG(TBSTATE_ENABLED, 0L));
  1409.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_ENABLED, 0L));
  1410.                 SendMessage(g_hwndTBar, TB_SETSTATE, IDM_SEEKTIMECODE, MAKELONG(TBSTATE_ENABLED, 0L));              
  1411.             } 
  1412.         }
  1413.         else
  1414.         {
  1415.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("IAMStreamConfig::GetFormat Failed. hr = 0x%x"), hr);
  1416.         } 
  1417.     }
  1418.     else    
  1419.     {
  1420.         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not get pointer to IAMStreamConfig. hr = 0x%x"), hr);
  1421.     }
  1422.  
  1423.     return bStatus;      
  1424.     
  1425. } 
  1426.  
  1427. /*-------------------------------------------------------------------------
  1428. Routine:        DV_MakeSpecialGraph
  1429. Purpose:        Makes any one of the special graphs needed for reading and writing to/from the DVCR
  1430. Arguments:    None
  1431. Returns:        BOOL as appropriate
  1432. Notes:          
  1433. ------------------------------------------------------------------------*/
  1434. BOOL DV_MakeSpecialGraph(GRAPH_TYPE iGraphType)
  1435. {
  1436.     BOOL bStatus = FALSE;
  1437.     HRESULT hr;
  1438.  
  1439.     //track whether the base or source filter is a file or the camera
  1440.     static BOOL bBaseFilterIsFile = FALSE;  
  1441.  
  1442.     // dont rebuild if the required graph already exists
  1443.     if(iGraphType == g_iCurrentGraph && g_pVideoRenderer != NULL)
  1444.     {
  1445.         bStatus = TRUE;
  1446.         return bStatus;
  1447.     }
  1448.  
  1449.     //stop the graph - this should never fail before rebuilding
  1450.     EXECUTE_ASSERT(SUCCEEDED(DV_StopGraph()));
  1451.  
  1452.     //let's look at the current graph
  1453.     //Disconnect everything
  1454.     if (bBaseFilterIsFile)
  1455.     {
  1456.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("disonnect downstream from the Filesource"));
  1457.         //DisconnectAll removes only the downstream filters - we need to remove the file filter by hand.
  1458.         DV_DisconnectAll(g_pInputFileFilter);
  1459.         if (g_pInputFileFilter)
  1460.         {
  1461.             hr = g_pGraphBuilder->RemoveFilter(g_pInputFileFilter);
  1462.             SAFE_RELEASE(g_pInputFileFilter);        
  1463.         }
  1464.     } 
  1465.     else
  1466.     {
  1467.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("disconnect downstream from the camera"));
  1468.         //DisconnectAll removes only the downstream filters - we need to remove the file filter by hand.
  1469.         DV_DisconnectAll(g_pDVCamera);
  1470.     }
  1471.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("Dumping Graph.  Pins should be disconnected"));
  1472.  
  1473.     switch (iGraphType)
  1474.     {
  1475.         // preview
  1476.         case GRAPH_PREVIEW :
  1477.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building Preview Graph"));
  1478.             // Build the preview graph by rendering via ICaptureGraphBuilder
  1479.             hr = g_pBuilder->RenderStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, g_pDVCamera,  NULL, NULL);
  1480.             if (SUCCEEDED(hr))
  1481.             {
  1482.                 hr = DV_SetPreview();
  1483.                 if (SUCCEEDED(hr))
  1484.                 {
  1485.                     bStatus = TRUE;
  1486.                     bBaseFilterIsFile = FALSE;
  1487.                 }
  1488.             } 
  1489.             else
  1490.             {
  1491.                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("RenderStream Failed. hr = 0x%x"), hr);
  1492.             }               
  1493.             break;
  1494.         //
  1495.         // Each of these type 1 & type 2 capture, transmit graphs have their graph building functions
  1496.         //
  1497.         // Type 1 File (capture & preview)
  1498.         case GRAPH_DV_TO_FILE :
  1499.         {
  1500.             if (SUCCEEDED(DV_MakeDvToFileGraph()))
  1501.             {
  1502.                 bStatus = TRUE;
  1503.                 bBaseFilterIsFile = FALSE;
  1504.             } 
  1505.             break;
  1506.         }
  1507.  
  1508.         // Type 1 File (capture)
  1509.         case GRAPH_DV_TO_FILE_NOPRE :
  1510.         {
  1511.             if (SUCCEEDED(DV_MakeDvToFileGraph_NoPre()))
  1512.             {
  1513.                 bStatus = TRUE;
  1514.                 bBaseFilterIsFile = FALSE;
  1515.             } 
  1516.             break;
  1517.         }
  1518.  
  1519.         // Type 1 File (transmit & playback)
  1520.         case GRAPH_FILE_TO_DV :
  1521.         {
  1522.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building Type 1 File to DV with Preview Graph"));
  1523.             if (SUCCEEDED(DV_MakeFileToDvGraph()))
  1524.             {
  1525.                 bBaseFilterIsFile = TRUE;  
  1526.                 bStatus = TRUE;
  1527.             } 
  1528.             break;
  1529.         }
  1530.         
  1531.         // Type 1 File (transmit)
  1532.         case GRAPH_FILE_TO_DV_NOPRE :
  1533.         {
  1534.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building Type 1 File to DV without Preview Graph"));
  1535.             if (SUCCEEDED(DV_MakeFileToDvGraph_NoPre()))
  1536.             {
  1537.                 bBaseFilterIsFile = TRUE;  
  1538.                 bStatus = TRUE;
  1539.             } 
  1540.             break;
  1541.         }
  1542.         
  1543.         // Type 2 File (capture & preview)
  1544.         case GRAPH_DV_TO_FILE_TYPE2 :
  1545.         {
  1546.             if (SUCCEEDED(DV_MakeDvToFileGraph_Type2()))
  1547.             {
  1548.                 bStatus = TRUE;
  1549.                 bBaseFilterIsFile = FALSE;
  1550.  
  1551.             } 
  1552.             break;
  1553.         }
  1554.  
  1555.         // Type 2 File (capture)
  1556.         case GRAPH_DV_TO_FILE_NOPRE_TYPE2 :
  1557.         {
  1558.             if (SUCCEEDED(DV_MakeDvToFileGraph_NoPre_Type2()))
  1559.             {
  1560.                 bStatus = TRUE;
  1561.                 bBaseFilterIsFile = FALSE;
  1562.             } 
  1563.             break;
  1564.         }
  1565.  
  1566.         // Type 2 File (transmit & playback)
  1567.         case GRAPH_FILE_TO_DV_TYPE2 :
  1568.         {
  1569.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building Type 2 File to DV with Preview Graph"));
  1570.             if (SUCCEEDED(DV_MakeFileToDvGraph_Type2()))
  1571.             {
  1572.                 bBaseFilterIsFile = TRUE;  
  1573.                 bStatus = TRUE;
  1574.             } 
  1575.             break;
  1576.         }
  1577.  
  1578.         // Type 2 File (transmit)
  1579.         case GRAPH_FILE_TO_DV_NOPRE_TYPE2 :
  1580.         {
  1581.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building Type 2 File to DV without Preview Graph"));
  1582.             if (SUCCEEDED(DV_MakeFileToDvGraph_NoPre_Type2()))
  1583.             {
  1584.                 bBaseFilterIsFile = TRUE;  
  1585.                 bStatus = TRUE;
  1586.             } 
  1587.             break;
  1588.         }
  1589.         
  1590.         default :
  1591.             // wrong graph type
  1592.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Invalid paramater passed to DV_MakeSpecialGraph"));
  1593.             return bStatus;
  1594.     } 
  1595.  
  1596.     // make sure you select MSDV as the master clock and not any of the renderers
  1597.     hr = DV_SelectClock(g_pDVCamera);
  1598.     return bStatus;
  1599. } 
  1600.  
  1601. /*-------------------------------------------------------------------------
  1602. Routine:        DV_SelectClock
  1603. Purpose:        Selects the Clock of the Filter sets it to be the clock of the Graph
  1604. Arguments:    Filter to be selected
  1605. Returns:        HResult as appropriate
  1606. Notes:          
  1607. ------------------------------------------------------------------------*/
  1608. HRESULT DV_SelectClock(IBaseFilter *pBaseFilter)
  1609. {
  1610.     HRESULT hr = S_OK;
  1611.     IReferenceClock *pRefClock      = NULL;
  1612.     IMediaFilter *pMediaFilter      = NULL;
  1613.  
  1614.     if(pBaseFilter == NULL)
  1615.         return E_POINTER;
  1616.     // QI for IReferenceClock on the specified filter
  1617.     hr = pBaseFilter->QueryInterface(IID_IReferenceClock, reinterpret_cast<PVOID *> (&pRefClock));
  1618.     // QI for IMediaFilter from the graph builder
  1619.     hr = g_pGraphBuilder->QueryInterface(IID_IMediaFilter, reinterpret_cast<PVOID *> (&pMediaFilter));
  1620.     if(pMediaFilter != NULL && pRefClock != NULL)
  1621.     {
  1622.         // set the clock of the specified filter on the filtergraph builder
  1623.         hr = pMediaFilter->SetSyncSource(pRefClock);
  1624.     }
  1625.     else
  1626.         hr = E_POINTER;
  1627.  
  1628.     SAFE_RELEASE(pMediaFilter);
  1629.     SAFE_RELEASE(pRefClock);
  1630.     return hr;
  1631. }       
  1632.  
  1633.  
  1634. /*-------------------------------------------------------------------------
  1635. Routine:        DV_StartGraph
  1636. Purpose:        Starts the Filter Graph 
  1637. Arguments:    None
  1638. Returns:        HResult as appropriate
  1639. Notes:          
  1640. ------------------------------------------------------------------------*/
  1641. HRESULT DV_StartGraph(void)
  1642. {
  1643.     HRESULT hr;
  1644.     IMediaControl *pMC = NULL;
  1645.  
  1646.     // QI for the media control 
  1647.     if(!g_pGraphBuilder)
  1648.         return S_FALSE;
  1649.     hr = g_pGraphBuilder->QueryInterface(IID_IMediaControl, reinterpret_cast<PVOID *>(&pMC));
  1650.     if (SUCCEEDED(hr))
  1651.     {
  1652.         // start the graph
  1653.         hr = pMC->Run();
  1654.         if ( FAILED(hr))
  1655.         {
  1656.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("IMediaControl::Run failed (0x%x)"), hr);
  1657.             // stop parts that ran
  1658.             pMC->Stop();
  1659.         }
  1660.         SAFE_RELEASE(pMC);
  1661.     }
  1662.     return hr;
  1663. }
  1664.  
  1665. /*-------------------------------------------------------------------------
  1666. Routine:        DV_PauseGraph
  1667. Purpose:        Starts the Filter Graph 
  1668. Arguments:    None
  1669. Returns:        HResult as appropriate
  1670. Notes:          
  1671. ------------------------------------------------------------------------*/
  1672. HRESULT DV_PauseGraph(void)
  1673. {
  1674.     HRESULT hr;
  1675.     IMediaControl *pMC = NULL;
  1676.     
  1677.     if(!g_pGraphBuilder)
  1678.         return S_FALSE;
  1679.     // QI for the media control 
  1680.     hr = g_pGraphBuilder->QueryInterface(IID_IMediaControl, reinterpret_cast<PVOID *>(&pMC));
  1681.     if (SUCCEEDED(hr))
  1682.     {
  1683.         // Pause the graph
  1684.         hr = pMC->Pause();
  1685.         if ( FAILED(hr))
  1686.         {
  1687.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("IMediaControl::Pause failed (0x%x)"), hr);
  1688.             // stop parts that ran
  1689.             pMC->Stop();
  1690.         }
  1691.         SAFE_RELEASE(pMC);
  1692.     }
  1693.     return hr;
  1694. }
  1695.  
  1696.  
  1697. /*-------------------------------------------------------------------------
  1698. Routine:        DV_StopGraph
  1699. Purpose:        Starts the Filter Graph 
  1700. Arguments:    None
  1701. Returns:        HResult as appropriate
  1702. Notes:          
  1703. ------------------------------------------------------------------------*/
  1704. HRESULT DV_StopGraph(void)
  1705. {
  1706.     HRESULT hr;
  1707.     IMediaControl *pMC = NULL;
  1708.  
  1709.     if(!g_pGraphBuilder)
  1710.         return S_FALSE;
  1711.     //stop the current graph
  1712.     hr = g_pGraphBuilder->QueryInterface(IID_IMediaControl, reinterpret_cast<PVOID *>(&pMC));
  1713.     if (SUCCEEDED(hr))
  1714.     {
  1715.         hr = pMC->Stop();
  1716.         SAFE_RELEASE(pMC);
  1717.     }
  1718.     return hr;
  1719. }
  1720.  
  1721. /*-------------------------------------------------------------------------
  1722. Routine:        DV_DisconnectAll
  1723. Purpose:        Disconnects all pins in a graph (downstream from pBF)   
  1724. Arguments:    pointer to the filter to disconnect pins from (downstream only)
  1725. Returns:        None
  1726. Notes:          This is the recursive nuke downstream routine from amcap
  1727. ------------------------------------------------------------------------*/
  1728. void DV_DisconnectAll(IBaseFilter *pBF)
  1729. {
  1730.     IPin *pP, *pTo;
  1731.     ULONG u;
  1732.     IEnumPins *pins = NULL;
  1733.     PIN_INFO pininfo;
  1734.  
  1735.     ASSERT(g_pGraphBuilder);
  1736.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("Disconnecting Pins..."));
  1737.    
  1738.     HRESULT hr = pBF->EnumPins(&pins);
  1739.     pins->Reset();
  1740.     while ( hr == NOERROR )
  1741.     {
  1742.         hr = pins->Next(1, &pP, &u);
  1743.         if ( hr == S_OK && pP )
  1744.         {
  1745.             pP->ConnectedTo(&pTo);
  1746.             if ( pTo )
  1747.             {
  1748.                 hr = pTo->QueryPinInfo(&pininfo);
  1749.                 if ( hr == NOERROR )
  1750.                 {
  1751.                     if ( pininfo.dir == PINDIR_INPUT )
  1752.                     {
  1753.                         DV_DisconnectAll(pininfo.pFilter);
  1754.                         hr = g_pGraphBuilder->Disconnect(pTo);
  1755.                         hr = g_pGraphBuilder->Disconnect(pP);
  1756.  
  1757.                         //always leave the Camera filter in the graph
  1758.                         //if the base filter is a file,the camera is downstream
  1759.                         if (pininfo.pFilter != g_pDVCamera)
  1760.                         {
  1761.                             hr = g_pGraphBuilder->RemoveFilter(pininfo.pFilter);
  1762.                         }
  1763.                     }
  1764.                     ASSERT(pininfo.pFilter);
  1765.                     SAFE_RELEASE(pininfo.pFilter);
  1766.                 }
  1767.                 ASSERT(pTo);
  1768.                 SAFE_RELEASE(pTo);
  1769.             }
  1770.             ASSERT(pP);
  1771.             SAFE_RELEASE(pP);
  1772.         }
  1773.     }
  1774.     if ( pins )
  1775.         SAFE_RELEASE(pins);
  1776.  
  1777. } 
  1778.  
  1779. /*-------------------------------------------------------------------------
  1780. Routine:        DV_CleanUp
  1781. Purpose:        writes values to the registry, releases all used interfaces. Uninitializes com and the dshow debug stuff
  1782. Arguments:    None
  1783. Returns:        None
  1784. Notes:          
  1785. ------------------------------------------------------------------------*/
  1786. void DV_CleanUp(void)
  1787. {
  1788.  
  1789.     DV_WriteRegKeys();
  1790.  
  1791.     // release helper dshow interfaces
  1792.     SAFE_RELEASE(g_pBuilder);
  1793.     SAFE_RELEASE(g_pExtDev);
  1794.     SAFE_RELEASE(g_pStreamConf);
  1795.     SAFE_RELEASE(g_pExtTrans);
  1796.     SAFE_RELEASE(g_pTimeReader);
  1797.     SAFE_RELEASE(g_pDroppedFrames);
  1798.     SAFE_RELEASE(g_pGraphBuilder);
  1799.  
  1800.     // release the filters of the graph    
  1801.     SAFE_RELEASE(g_pDVCamera);    
  1802.     SAFE_RELEASE(g_pVideoWindow);
  1803.     SAFE_RELEASE(g_pInputFileFilter);
  1804.     SAFE_RELEASE(g_pInfTee);
  1805.     SAFE_RELEASE(g_pVideoRenderer);
  1806.     SAFE_RELEASE(g_pAviSplitter);
  1807.     SAFE_RELEASE(g_pDVSplitter); 
  1808.     SAFE_RELEASE(g_pDVCodec);
  1809.     SAFE_RELEASE(g_pDvDec);
  1810.     SAFE_RELEASE(g_pDVMux);
  1811.     SAFE_RELEASE(g_pSmartTee);     
  1812.     SAFE_RELEASE(g_pDSound);
  1813.  
  1814.     CoUninitialize();
  1815. } 
  1816.  
  1817.  
  1818. /*-------------------------------------------------------------------------
  1819. Routine:        DV_SetPreview
  1820. Purpose:        Hooks up stream  *from camera* to preview window
  1821.                     Note that the preview for the playback from the file is handled within DV_MakeFileToDvGraph() stuff
  1822. Arguments:    None
  1823. Returns:        HRESULT as appropriate
  1824. Notes:          
  1825. ------------------------------------------------------------------------*/
  1826. HRESULT DV_SetPreview(void)
  1827. {
  1828.     HRESULT hr = S_OK;
  1829.  
  1830.     if (g_pVideoWindow)
  1831.     {   // dismantle the current video window
  1832.         g_pVideoWindow->put_Owner(NULL);
  1833.         SAFE_RELEASE(g_pVideoWindow);
  1834.     } 
  1835.  
  1836.     // get the video window and set it up for the preview
  1837.     hr = g_pBuilder->FindInterface(NULL, &MEDIATYPE_Video, g_pDVCamera, IID_IVideoWindow, reinterpret_cast<PVOID *>(&g_pVideoWindow));
  1838.     if (SUCCEEDED(hr))
  1839.     {        
  1840.         RECT rc, rect;
  1841.         g_pVideoWindow->put_Owner((LONG_PTR)g_hwndApp);     // We own the window now
  1842.         g_pVideoWindow->put_WindowStyle(WS_CHILD);     // you are now a child
  1843.  
  1844.         // give the preview window all our space but where the tool bar and status bar are        
  1845.         GetClientRect(g_hwndApp, &rc);
  1846.         GetWindowRect(g_hwndTBar, &rect);
  1847.  
  1848.         //g_pVideoWindow->SetWindowPosition(0, rect.bottom - rect.top, rc.right, 
  1849.         //      (rc.bottom - (g_statusHeight + GetSystemMetrics(SM_CYBORDER)) - (rect.bottom - rect.top)));
  1850.  
  1851.         g_pVideoWindow->SetWindowPosition(0, rect.bottom - rect.top, g_iVWWidth, g_iVWHeight);
  1852.         g_pVideoWindow->put_Visible(OATRUE);
  1853.     }
  1854.     else
  1855.     {
  1856.         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("FindInterface (IVideoWindow) Failed. hr = 0x%x"), hr);
  1857.     }
  1858.  
  1859.     return hr;
  1860. } 
  1861.  
  1862. /*-------------------------------------------------------------------------
  1863. Routine:        DV_GetDVMode
  1864. Purpose:        Determines camera mode using IAMExtDevice::GetCapability()
  1865. Arguments:    None
  1866. Returns:        Current mode of camera device
  1867. Notes:          
  1868. ------------------------------------------------------------------------*/
  1869. DV_MODE DV_GetDVMode(void)
  1870. {
  1871.     HRESULT hr = S_OK;
  1872.     LONG    lDeviceType = 0;
  1873.  
  1874.     ASSERT(g_pExtDev);
  1875.     //  Query the Device Type Capability
  1876.     hr = g_pExtDev->GetCapability(ED_DEVCAP_DEVICE_TYPE, &lDeviceType, 0);
  1877.     if (SUCCEEDED(hr))
  1878.     {
  1879.         switch (lDeviceType)
  1880.         {
  1881.             case 0 :
  1882.                 //device type is unknown
  1883.                 g_CurrentMode = UnknownMode;
  1884.                 break;
  1885.  
  1886.             case ED_DEVTYPE_VCR :
  1887.                 g_CurrentMode = VcrMode;
  1888.                 break;
  1889.  
  1890.             case ED_DEVTYPE_CAMERA :
  1891.                 g_CurrentMode = CameraMode;
  1892.                 break;
  1893.  
  1894.             default :
  1895.                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("GetCapability returned an unknown device type - 0x%x"), lDeviceType);
  1896.                 break;
  1897.         } 
  1898.     }
  1899.     return g_CurrentMode;
  1900. } 
  1901.  
  1902. /*-------------------------------------------------------------------------
  1903. Routine:        DV_TimecodeTimerProc
  1904. Purpose:        Callback function for the timer proc
  1905. Arguments:    Usual Timer Processing Parameters
  1906. Returns:        None
  1907. Notes:          
  1908. ------------------------------------------------------------------------*/
  1909. void CALLBACK DV_TimecodeTimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
  1910. {
  1911.     DV_DisplayTimecode();
  1912. } 
  1913.  
  1914. /*-------------------------------------------------------------------------
  1915. Routine:        DV_StopRecProc
  1916. Purpose:        Callback to stop recording after a specified time
  1917. Arguments:    Usual Timer Processing Parameters
  1918. Returns:        None
  1919. Notes:          
  1920. ------------------------------------------------------------------------*/
  1921. void CALLBACK DV_StopRecProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
  1922. {
  1923.     SendMessage(g_hwndApp, WM_COMMAND, IDM_STOP, 0);
  1924. } 
  1925.  
  1926.  
  1927. /*-------------------------------------------------------------------------
  1928. Routine:        DV_GetFinalDroppedFramesStats
  1929. Purpose:        Get Final dropped frames stats for status bar display
  1930. Arguments:    DWORD current time
  1931. Returns:        None
  1932. Notes:          For both Capture & Transmit graphs
  1933. ------------------------------------------------------------------------*/
  1934. void DV_GetFinalDroppedFramesStats(DWORD dwTime)
  1935. {
  1936.     BOOL bIsModeTransmit = TRUE;
  1937.     // determine if the current graph is a transmit graph
  1938.     if (GRAPH_DV_TO_FILE_NOPRE == g_iCurrentGraph || GRAPH_DV_TO_FILE == g_iCurrentGraph ||
  1939.                 GRAPH_DV_TO_FILE_TYPE2 == g_iCurrentGraph || GRAPH_DV_TO_FILE_NOPRE_TYPE2 == g_iCurrentGraph)
  1940.         bIsModeTransmit = FALSE;
  1941.  
  1942.     // make sure the interface exists ans can be queried the stats
  1943.     if (g_pDroppedFrames)
  1944.     {
  1945.         HRESULT hr = S_OK;
  1946.         long dropped = 0, notdropped = 0, lAvgFrameSize = 0;
  1947.         TCHAR buffer[128];
  1948.         DWORD time = dwTime - g_CapStartTime;
  1949.  
  1950.         // Get the required stats
  1951.         hr = g_pDroppedFrames->GetNumDropped(&dropped);
  1952.         hr = g_pDroppedFrames->GetNumNotDropped(¬dropped);
  1953.         hr = g_pDroppedFrames->GetAverageFrameSize(&lAvgFrameSize);
  1954.         
  1955.         if (SUCCEEDED(hr) && time != 0)
  1956.         {   
  1957.             double  framerate = 0;      // acheived frame rate
  1958.             LONG    lData     = 0;      // acheived data rate
  1959.             // Calculate other stats
  1960.             framerate = (double)(LONGLONG)notdropped * 1000. / (double)(LONGLONG)time;
  1961.             lData = (LONG)(LONGLONG)(notdropped / (double)(LONGLONG)time * 1000. * (double)(LONGLONG)lAvgFrameSize);
  1962.             if(bIsModeTransmit)
  1963.                 wsprintf(buffer, TEXT("Transmitted %d frames (%d dropped) %d.%d sec. %d.%d fps %d.%d Meg/sec"), 
  1964.                              notdropped, dropped, time / 1000, time / 100 - time / 1000 * 10,
  1965.                              (int)framerate, (int)(framerate * 10.) - (int)framerate * 10, 
  1966.                              lData / 1000000, lData / 1000 - (lData / 1000000 * 1000));
  1967.             else
  1968.                 wsprintf(buffer, TEXT("Captured %d frames (%d dropped) %d.%d sec. %d.%d fps %d.%d Meg/sec"), 
  1969.                              notdropped, dropped, time / 1000, time / 100 - time / 1000 * 10,
  1970.                              (int)framerate, (int)(framerate * 10.) - (int)framerate * 10, 
  1971.                              lData / 1000000, lData / 1000 - (lData / 1000000 * 1000));
  1972.             // update the status bar with the gathered info        
  1973.             DV_StatusText(buffer, 1);
  1974.         }
  1975.         else
  1976.            {
  1977.                DV_StatusText(TEXT("Cannot report dropped frame information"), 1);
  1978.         } 
  1979.     }
  1980. }    
  1981.  
  1982. /*-------------------------------------------------------------------------
  1983. Routine:        DV_DroppedFrameProc
  1984. Purpose:        Callback proc to display dropped frame info
  1985. Arguments:    DWORD current time
  1986. Returns:        None
  1987. Notes:          For both Capture & Transmit graphs
  1988. ------------------------------------------------------------------------*/
  1989. void CALLBACK DV_DroppedFrameProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
  1990. {
  1991.     HRESULT hr = S_OK;
  1992.     long dropped = 0, notdropped = 0;
  1993.     TCHAR buffer[128];
  1994.     DWORD time = dwTime - g_CapStartTime;
  1995.     BOOL bIsModeTransmit = TRUE;
  1996.  
  1997.     // if the dropped frames interface does not already exist, query now!
  1998.     if (NULL == g_pDroppedFrames) {
  1999.         if (GRAPH_DV_TO_FILE == g_iCurrentGraph || GRAPH_DV_TO_FILE_NOPRE == g_iCurrentGraph ||
  2000.             GRAPH_DV_TO_FILE_TYPE2 == g_iCurrentGraph || GRAPH_DV_TO_FILE_NOPRE_TYPE2 == g_iCurrentGraph)
  2001.         {
  2002.             hr = g_pBuilder->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, g_pDVCamera, IID_IAMDroppedFrames, reinterpret_cast<PVOID *>(&g_pDroppedFrames));
  2003.             bIsModeTransmit = FALSE;
  2004.         }
  2005.         else if (GRAPH_FILE_TO_DV == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE == g_iCurrentGraph ||
  2006.             GRAPH_FILE_TO_DV_TYPE2 == g_iCurrentGraph || GRAPH_FILE_TO_DV_NOPRE_TYPE2 == g_iCurrentGraph)
  2007.         {
  2008.             IPin *pAVIn = NULL;
  2009.              hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_INPUT, NULL, NULL, FALSE, 0, &pAVIn);
  2010.             if(SUCCEEDED(hr) && pAVIn != NULL)
  2011.                 hr = pAVIn->QueryInterface(IID_IAMDroppedFrames, reinterpret_cast<PVOID *>(&g_pDroppedFrames));
  2012.             else 
  2013.                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not get Input Pin for obtaining Dropped Frames Statistics"));
  2014.         }
  2015.         else
  2016.         {
  2017.             //we shouldn't get here as we dont call for the dropped frames in preview graph
  2018.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Undefined graph mode (maybe GRAPH_PREVIEW) while obtaining Dropped Frames"));
  2019.         } 
  2020.     }
  2021.  
  2022.     if (SUCCEEDED(hr))
  2023.     {
  2024.         // Get the stats once the interface is successfully obtained
  2025.         hr = g_pDroppedFrames->GetNumDropped(&dropped);
  2026.         hr = g_pDroppedFrames->GetNumNotDropped(¬dropped);
  2027.         if (SUCCEEDED(hr))
  2028.         {          
  2029.             if(bIsModeTransmit)
  2030.                 wsprintf(buffer, TEXT("Transmitted %d frames (%d dropped) %d.%d sec."), notdropped, dropped, time / 1000, time / 100 - time / 1000 * 10);
  2031.             else
  2032.                    wsprintf(buffer, TEXT("Captured %d frames (%d dropped) %d.%d sec."), notdropped, dropped, time / 1000, time / 100 - time / 1000 * 10);
  2033.             // update the status bar
  2034.             DV_StatusText(buffer, 1);
  2035.         }
  2036.         else
  2037.         {
  2038.             DV_StatusText(TEXT("Cannot report dropped frame information"), 1);
  2039.         } 
  2040.     } 
  2041.     else
  2042.     {
  2043.            DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not get IAMDroppedFrames interface"));
  2044.         KillTimer(hwnd, DV_TIMER_FRAMES);
  2045.     } 
  2046.  
  2047. } 
  2048.  
  2049.  
  2050.  
  2051. /*-------------------------------------------------------------------------
  2052. Routine:        DV_DisplayTimecode
  2053. Purpose:        Routine to display timecodes
  2054. Arguments:    None
  2055. Returns:        None
  2056. Notes:          This is TimeCode Read not Absolute Track Number Read
  2057. ------------------------------------------------------------------------*/
  2058. void DV_DisplayTimecode(void)
  2059. {
  2060.     TIMECODE_SAMPLE TimecodeSample;
  2061.     TimecodeSample.timecode.dwFrames = 0;
  2062.     static DWORD i1 = 0, i2 = 0, i3 = 0;
  2063.  
  2064.     TimecodeSample.dwFlags = ED_DEVCAP_TIMECODE_READ;
  2065.     // Query the TimeCode sample data
  2066.     HRESULT hr = g_pTimeReader->GetTimecode(&TimecodeSample);
  2067.     TCHAR szBuf[4];
  2068.  
  2069.     if (SUCCEEDED(hr))
  2070.     {
  2071.         // It's worth it to spend a few extra cycles, and to store the static variables
  2072.         // to avoid calling wsprintf and setwindowtext on every timer tick.
  2073.         if (i1 != (TimecodeSample.timecode.dwFrames & 0xff000000) >> 24)
  2074.         {
  2075.             wsprintf(szBuf, TEXT("%.2x"),((TimecodeSample.timecode.dwFrames & 0xff000000) >> 24));
  2076.             SetDlgItemText(g_hwndTBar, IDC_EDIT_HOUR, szBuf);
  2077.         } 
  2078.         i1 = (TimecodeSample.timecode.dwFrames & 0xff000000) >> 24;
  2079.  
  2080.         if (i2 != (TimecodeSample.timecode.dwFrames & 0x00ff0000) >> 16)
  2081.         {
  2082.             wsprintf(szBuf, TEXT("%.2x"),((TimecodeSample.timecode.dwFrames & 0x00ff0000) >> 16));
  2083.             SetDlgItemText(g_hwndTBar, IDC_EDIT_MINUTE, szBuf);
  2084.         } 
  2085.         i2 = (TimecodeSample.timecode.dwFrames & 0x00ff0000) >> 16;
  2086.         
  2087.         if (i3 != (TimecodeSample.timecode.dwFrames & 0x0000ff00) >>  8)
  2088.         {
  2089.             wsprintf(szBuf, TEXT("%.2x"),((TimecodeSample.timecode.dwFrames & 0x0000ff00) >>  8));
  2090.             SetDlgItemText(g_hwndTBar, IDC_EDIT_SECOND, szBuf);
  2091.         } 
  2092.         i3 = (TimecodeSample.timecode.dwFrames & 0x0000ff00) >>  8;
  2093.  
  2094.         //always update the toolbar display
  2095.         wsprintf(szBuf, TEXT("%.2x"),(TimecodeSample.timecode.dwFrames & 0x000000ff));
  2096.         SetDlgItemText(g_hwndTBar, IDC_EDIT_FRAME, szBuf);
  2097.     }
  2098.     else
  2099.     {
  2100.         DV_LogOut(LOG_PRIORITY_WARN, LOG_LEVEL_MEDIUM, TEXT("Failed to get Timecodesample.  hr = 0x%x"), hr);
  2101.     } 
  2102. } 
  2103.  
  2104.  
  2105. /*-------------------------------------------------------------------------
  2106. Routine:        DV_SeekATN
  2107. Purpose:        ATN Seek function - uses GetTransportBasicParameters to send RAW AVC command 
  2108. Arguments:    None
  2109. Returns:        TRUE if successful
  2110. Notes:          This is Absolute Track Number Seek not TimeCode Seek but uses the timecode display as input
  2111. ------------------------------------------------------------------------*/
  2112. BOOL DV_SeekATN(void)
  2113. {
  2114.     BOOL bStatus = FALSE;
  2115.     HRESULT hr = S_OK;
  2116.     int iHr, iMn, iSc, iFr;
  2117.     ULONG ulTrackNumToSearch;
  2118.     long iCnt = 8;
  2119.     // ATN Seek Raw AVC Command 
  2120.     BYTE RawAVCPkt[8] = {0x00, 0x20, 0x52, 0x20, 0xff, 0xff, 0xff, 0xff};
  2121.  
  2122.     //get the values from the edit fields
  2123.     iHr = GetDlgItemInt(g_hwndTBar, IDC_EDIT_HOUR,   &bStatus, FALSE);
  2124.     iMn = GetDlgItemInt(g_hwndTBar, IDC_EDIT_MINUTE, &bStatus, FALSE);
  2125.     iSc = GetDlgItemInt(g_hwndTBar, IDC_EDIT_SECOND, &bStatus, FALSE);
  2126.     iFr = GetDlgItemInt(g_hwndTBar, IDC_EDIT_FRAME,  &bStatus, FALSE);
  2127.  
  2128.     if ((iHr < 60) && (iMn < 60) && (iSc < 60) && (iFr <=30))
  2129.     {
  2130.         //Calculate the ATN
  2131.         if (g_AvgTimePerFrame == 40) 
  2132.         {
  2133.             ulTrackNumToSearch = ((iMn * 60 + iSc) * 25 + iFr) * 12 * 2;
  2134.         } 
  2135.         else 
  2136.         {
  2137.             // Drop two frame every minutes
  2138.             ulTrackNumToSearch = ((iMn * 60 + iSc) * 30 + iFr - ((iMn - (iMn / 10)) * 2)) * 10 * 2;
  2139.         }
  2140.         // Update the Raw AVC Command query
  2141.         RawAVCPkt[4] = (BYTE)  (ulTrackNumToSearch & 0x000000ff);
  2142.         RawAVCPkt[5] = (BYTE) ((ulTrackNumToSearch & 0x0000ff00) >> 8);
  2143.         RawAVCPkt[6] = (BYTE) ((ulTrackNumToSearch & 0x00ff0000) >> 16);
  2144.         
  2145.         // RAW AVC Call
  2146.         hr = g_pExtTrans->GetTransportBasicParameters(ED_RAW_EXT_DEV_CMD, &iCnt, (LPOLESTR *)RawAVCPkt);
  2147.         Sleep(_MAX_SLEEP*6);
  2148.         if (SUCCEEDED(hr))
  2149.         {
  2150.             bStatus = TRUE;
  2151.         }
  2152.         else
  2153.         {
  2154.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Seek to a TimeCode Location failed"));
  2155.         }
  2156.     }
  2157.     else
  2158.     {
  2159.         MBOX(TEXT("Invalid Parameter - Time entered should be:\nHour:Minute:Second:Frame"));
  2160.     } 
  2161.     return bStatus;
  2162. } 
  2163.  
  2164. /*---------------------------------------------------------------------------------------------------------
  2165. Routine:        DV_MakeDvToFileGraph
  2166. Purpose:        Builds and runs the DV to File graph
  2167. Arguments:    None
  2168. Returns:        HRESULT as apropriate
  2169. Notes:          This is a capture & preview graph for DV Type 1 AVI files           
  2170.                     This graph is a bit more complex.  It looks like this:
  2171.                     DV_Cam(AV Out)->SmartTee(capture)->AviMux->FileWriter
  2172.                                                 SmartTee(preview)->DVSplitter(vid)->DVCodec->VideoWindow
  2173.                                                                                 DVSplitter(aud)->Default DirectSound device
  2174. ---------------------------------------------------------------------------------------------------------*/
  2175. HRESULT DV_MakeDvToFileGraph(void)
  2176. {
  2177.     HRESULT hr = S_OK;
  2178.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building DV to File Graph"));
  2179.     // making sure there is a output file selected
  2180.     if (!g_OutputFileName[0])
  2181.     {
  2182.         MBOX(TEXT("Please set up an output file name for recording"));
  2183.         hr = E_FAIL;
  2184.     } 
  2185.     else
  2186.     {
  2187.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("This is the graph - everything should be disconnected"));
  2188.  
  2189. #ifndef UNICODE        
  2190.         // convert the output file name to wchar
  2191.         WCHAR wFileName[MAX_PATH];
  2192.         MultiByteToWideChar(CP_ACP, 0, g_OutputFileName, -1, wFileName, MAX_PATH);
  2193. #endif
  2194.  
  2195.         //we need a lot of pins to make this work...
  2196.         IPin *pAVOut = NULL, *pTeeIn = NULL, *pTeeOut = NULL, *pMuxIn = NULL, *pTeePreOut = NULL, *pSplitIn = NULL;
  2197.         IPin *pSplitVout = NULL, *pSplitAout = NULL, *pAudIn = NULL, *pCodecIn = NULL, *pCodecOut = NULL, *pRenderIn = NULL;
  2198.  
  2199.         //get the camera output pin
  2200.         hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_OUTPUT, NULL, &MEDIATYPE_Interleaved, TRUE, 0, &pAVOut);
  2201.         //add the smart tee filter, get the smart tee input pin and connect it to the DV Cam AV out
  2202.         if (SUCCEEDED(hr))
  2203.         {
  2204.             g_pGraphBuilder->AddFilter(g_pSmartTee, L"Smart Tee");           
  2205.             hr = g_pBuilder->FindPin(g_pSmartTee, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pTeeIn);
  2206.             if (SUCCEEDED(hr))
  2207.             {
  2208.                 hr = g_pGraphBuilder->ConnectDirect(pAVOut, pTeeIn, NULL);
  2209.                 if (SUCCEEDED(hr))
  2210.                 {
  2211.                     // get the capture output pin of smart tee and connect it to avi muxer & file writer
  2212.                     hr = g_pBuilder->FindPin(g_pSmartTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pTeeOut);
  2213.                     if (SUCCEEDED(hr))
  2214.                     {
  2215.                         //add the avimux, and file writer to the graph 
  2216.                         IBaseFilter *ppf = NULL;
  2217.                         IFileSinkFilter *pSink = NULL;
  2218. #ifndef UNICODE
  2219.                         hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, wFileName, &ppf, &pSink);
  2220. #else
  2221.                         hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, g_OutputFileName, &ppf, &pSink);
  2222. #endif //UNICODE
  2223.                         if (SUCCEEDED(hr))
  2224.                         {
  2225.                             // Set the AVI Options like interleaving mode etc...
  2226.                             DV_SetAviOptions(ppf, INTERLEAVE_NONE);
  2227.                             //Now I need the input pin on the mux to connect to the file writer
  2228.                             hr = g_pBuilder->FindPin(ppf, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxIn);
  2229.                             if (SUCCEEDED(hr))
  2230.                             {
  2231.                                 hr = g_pGraphBuilder->ConnectDirect(pTeeOut, pMuxIn, NULL);
  2232.                                 //
  2233.                                 //the capture graph is built,but we still need to build the preview graph
  2234.                                 //
  2235.                                 // get the preview output pin on the smart tee
  2236.                                 hr = g_pBuilder->FindPin(g_pSmartTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pTeePreOut);
  2237.                                  if (SUCCEEDED(hr))
  2238.                                 {
  2239.                                     // Add the filters DV Splitter, DV Decoder, Video Renderer 
  2240.                                     EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVSplitter, L"DV Splitter"));
  2241.                                     EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVCodec, L"DV Codec"));
  2242.                                     EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pVideoRenderer, L"VideoRenderer"));
  2243.  
  2244.                                     // Find input pin of dvsplitter & connect smart tee and dvsplitter
  2245.                                     hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitIn);
  2246.                                     if (SUCCEEDED(hr))
  2247.                                     {
  2248.                                         hr = g_pGraphBuilder->ConnectDirect(pTeePreOut, pSplitIn, NULL);
  2249.                                         if (SUCCEEDED(hr))
  2250.                                         {
  2251.                                             // find the vid & aud output pins on the dvsplitter
  2252.                                             hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL , &MEDIATYPE_Video, TRUE, 0, &pSplitVout);
  2253.                                             if (SUCCEEDED(hr))
  2254.                                             {
  2255.                                                 hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL , &MEDIATYPE_Audio, TRUE, 0, &pSplitAout);
  2256.                                                 if (SUCCEEDED(hr))
  2257.                                                 {
  2258.                                                     // find the input & output pins on the dv codec
  2259.                                                     hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pCodecIn);
  2260.                                                     if (SUCCEEDED(hr))
  2261.                                                     {
  2262.                                                         hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_OUTPUT, NULL , NULL, TRUE, 0, &pCodecOut);
  2263.                                                         if (SUCCEEDED(hr))
  2264.                                                         {
  2265.                                                             // connect the dvsplitter(vid) & dvcodec
  2266.                                                             hr = g_pGraphBuilder->ConnectDirect(pSplitVout, pCodecIn, NULL);
  2267.                                                             if (SUCCEEDED(hr))
  2268.                                                             {
  2269.                                                                 //if we have audio, add the filter to the graph connect it to the dvsplitter(aud)
  2270.                                                                 if (g_pDSound)
  2271.                                                                 {
  2272.                                                                     EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDSound, L"DSound"));
  2273.                                                                     hr = g_pBuilder->FindPin(g_pDSound, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pAudIn);
  2274.                                                                     if (SUCCEEDED(hr))
  2275.                                                                     {
  2276.                                                                         hr = g_pGraphBuilder->ConnectDirect(pSplitAout, pAudIn, NULL);
  2277.                                                                         SAFE_RELEASE(pAudIn);
  2278.                                                                     }
  2279.                                                                 }   
  2280.                                                                 if (SUCCEEDED(hr))  //this verifies success of the audio connection when audio exists
  2281.                                                                 {
  2282.                                                                     // get the input pin on the video renderer and connect it to the dvcodec
  2283.                                                                     hr = g_pBuilder->FindPin(g_pVideoRenderer, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pRenderIn);
  2284.                                                                     if (SUCCEEDED(hr))
  2285.                                                                     {
  2286.                                                                         hr = g_pGraphBuilder->ConnectDirect(pCodecOut, pRenderIn, NULL);
  2287.                                                                         if (SUCCEEDED(hr))
  2288.                                                                         {
  2289.                                                                             // Woohoo! succeeded all the way
  2290.                                                                             // Set the Filter Graph to Preview State (Run in this case)
  2291.                                                                             DV_SetPreview();
  2292.                                                                         } 
  2293.                                                                         SAFE_RELEASE(pRenderIn);
  2294.                                                                     } 
  2295.                                                                 } 
  2296.                                                             } 
  2297.                                                             SAFE_RELEASE(pCodecOut);
  2298.                                                         } 
  2299.                                                         SAFE_RELEASE(pCodecIn);
  2300.                                                     } 
  2301.                                                     SAFE_RELEASE(pSplitAout);
  2302.                                                 } 
  2303.                                                 SAFE_RELEASE(pSplitVout);
  2304.                                             } 
  2305.                                         } 
  2306.                                         SAFE_RELEASE(pSplitIn);
  2307.                                     } 
  2308.                                     SAFE_RELEASE(pTeePreOut);
  2309.                                 } 
  2310.                                 SAFE_RELEASE(pMuxIn);
  2311.                             } 
  2312.                             SAFE_RELEASE(ppf);
  2313.                             SAFE_RELEASE(pSink);
  2314.                         } 
  2315.                         SAFE_RELEASE(pTeeOut);
  2316.                     } 
  2317.                 } // Release interfaces appropriately
  2318.                 else
  2319.                 {
  2320.                     DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from camera (0x%x)"), hr);
  2321.                 } 
  2322.                 SAFE_RELEASE(pTeeIn);
  2323.             } 
  2324.             SAFE_RELEASE(pAVOut);
  2325.         } 
  2326.     }
  2327.     return hr;
  2328. }
  2329.  
  2330. /*---------------------------------------------------------------------------------------------------------
  2331. Routine:        DV_MakeDvToFileGraph_NoPre
  2332. Purpose:        Builds and runs the DV to File graph with no preview
  2333. Arguments:    None
  2334. Returns:        HRESULT as apropriate
  2335. Notes:          This is a capture only graph for DV Type 1 AVI files            
  2336.                     This graph is not too complex.  It looks like this:
  2337.                     DV_Cam(AV Out)->AviMux->FileWriter
  2338. ---------------------------------------------------------------------------------------------------------*/
  2339. HRESULT  DV_MakeDvToFileGraph_NoPre(void)
  2340. {
  2341.     HRESULT hr = S_OK;
  2342.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building DV to File Graph (No Preview)"));
  2343.     // making sure there is a output file selected
  2344.     if (!g_OutputFileName[0])
  2345.     {
  2346.         MBOX(TEXT("Please set up an output file name for recording"));
  2347.         hr = E_FAIL;
  2348.     } 
  2349.     else
  2350.     {
  2351.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("This is the graph - everything should be disconnected"));
  2352. #ifndef UNICODE        
  2353.         // convert the output file name to wchar
  2354.         WCHAR wFileName[MAX_PATH];
  2355.         MultiByteToWideChar(CP_ACP, 0, g_OutputFileName, -1, wFileName, MAX_PATH);
  2356. #endif
  2357.  
  2358.         //we'll need a few pins...
  2359.         IPin *pAVOut = NULL, *pMuxIn = NULL;
  2360.  
  2361.         // get the capture output pin of dvcamera and connect it to avi muxer & file writer
  2362.         hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_OUTPUT, NULL, &MEDIATYPE_Interleaved, TRUE, 0, &pAVOut);
  2363.         if (SUCCEEDED(hr))
  2364.         {
  2365.             //add the avimux, and file writer to the graph 
  2366.             IBaseFilter *ppf = NULL;
  2367.             IFileSinkFilter *pSink = NULL;
  2368. #ifndef UNICODE
  2369.             hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, wFileName, &ppf, &pSink);
  2370. #else
  2371.             hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, g_OutputFileName, &ppf, &pSink);
  2372. #endif //UNICODE
  2373.             if (SUCCEEDED(hr))
  2374.             {
  2375.                 // Set the AVI Options like interleaving mode etc...
  2376.                 DV_SetAviOptions(ppf, INTERLEAVE_NONE);
  2377.                 //Now I need the input pin on the mux to connect to the file writer
  2378.                 hr = g_pBuilder->FindPin(ppf, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxIn);
  2379.                 if (SUCCEEDED(hr))
  2380.                 {
  2381.                     hr = g_pGraphBuilder->ConnectDirect(pAVOut, pMuxIn, NULL);
  2382.                     //
  2383.                     //the capture graph is built
  2384.                     //
  2385.                     if (FAILED(hr))
  2386.                     {
  2387.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from camera (0x%x)"), hr);
  2388.                     } 
  2389.                                                             
  2390.                     SAFE_RELEASE(pMuxIn);
  2391.                 } 
  2392.                 SAFE_RELEASE(ppf);
  2393.                 SAFE_RELEASE(pSink);
  2394.             } 
  2395.             
  2396.         } 
  2397.         SAFE_RELEASE(pAVOut);
  2398.     } // Release interfaces appropriately
  2399.     return hr;
  2400. }
  2401.  
  2402. /*---------------------------------------------------------------------------------------------------------
  2403. Routine:        DV_MakeFileToDvGraph
  2404. Purpose:        Builds and runs the File to DV graph
  2405. Arguments:    None
  2406. Returns:        HRESULT as apropriate
  2407. Notes:          This is a transmit & playback graph for DV Type 1 AVI files         
  2408.                     This graph is a bit more complex.  It looks like this:
  2409.                      FileSource->AVI_Splitter->InfPinTee->DV_Camera
  2410.                                                                InfPinTee->DVSplitter(vid)->DVDecoder->VideoWIndow
  2411.                                                                                 DVSplitter(aud)->Default DirectSound device
  2412. ---------------------------------------------------------------------------------------------------------*/
  2413. HRESULT DV_MakeFileToDvGraph(void)
  2414. {
  2415.     HRESULT hr = S_OK;
  2416.     // making sure there is a input file selected
  2417.     if (NULL == g_InputFileName[0])
  2418.     {
  2419.         MBOX(TEXT("Please set an input file for rendering"));
  2420.         hr = E_FAIL;
  2421.     } 
  2422.     else
  2423.     {
  2424.          //if we are compiling ANSI, the file name needs to be converted to UNICODE
  2425.         // Add the file as source filter to the graph
  2426.  #ifndef UNICODE
  2427.        WCHAR wFileName[MAX_PATH];
  2428.         MultiByteToWideChar(CP_ACP, 0, g_InputFileName, -1, wFileName, MAX_PATH);
  2429.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(wFileName, wFileName, &g_pInputFileFilter));
  2430. #else
  2431.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(g_InputFileName, g_InputFileName, &g_pInputFileFilter));
  2432. #endif
  2433.         //making sure the file source exists
  2434.         if(g_pInputFileFilter == NULL)
  2435.         {
  2436.             MBOX(TEXT("Please set a correct input file for rendering"));
  2437.             hr = E_FAIL;
  2438.             return hr;
  2439.         } 
  2440.         // Also add the AVI Splitter
  2441.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pAviSplitter, L"AVI Splitter"));
  2442.  
  2443.         // now we need to connect the pins
  2444.         IPin *pFileOut = NULL, *pSplitterIn = NULL, *pSplitterOut = NULL, *pDvIn = NULL;
  2445.         IPin *pInfTeeIn = NULL, *pInfTeeOut1 = NULL, *pInfTeeOut2 = NULL, *pSplitIn = NULL, *pRenderIn = NULL;
  2446.         IPin *pSplitVout = NULL, *pSplitAout = NULL, *pCodecIn = NULL, *pCodecOut = NULL, *pAudIn = NULL;
  2447.  
  2448.         // obtain the output pin of the source filter and connect it to avi splitter
  2449.         hr = g_pBuilder->FindPin(g_pInputFileFilter, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pFileOut);
  2450.         if (SUCCEEDED(hr))
  2451.         {
  2452.             ASSERT(pFileOut);
  2453.             //now get the input pin of the splitter
  2454.             hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitterIn);
  2455.             if (SUCCEEDED(hr))
  2456.             {
  2457.                 ASSERT(pSplitterIn);
  2458.                 //connect the file output pin to the AVI splitter in
  2459.                 //until we do this, the output pin on the splitter won't appear
  2460.                 hr = g_pGraphBuilder->ConnectDirect(pFileOut, pSplitterIn, NULL);
  2461.                 if (SUCCEEDED(hr))
  2462.                 {
  2463.                     //now we can connect the AVISplitterOut to the InfTee IN, then connect that to the camera
  2464.                     hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pSplitterOut);
  2465.                     if (SUCCEEDED(hr))
  2466.                     {
  2467.                         ASSERT(pSplitterOut);
  2468.                         //add the the infinite pin tee filter to the graph
  2469.                         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pInfTee, L"Infinite Tee")); 
  2470.                         hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pInfTeeIn);
  2471.                         if (SUCCEEDED(hr))
  2472.                         {
  2473.                             ASSERT(pInfTeeIn);
  2474.                             hr = g_pGraphBuilder->ConnectDirect(pSplitterOut, pInfTeeIn, NULL);
  2475.                             if (SUCCEEDED(hr))
  2476.                             {
  2477.                                 //get the inftee output pin, and the DV Camera input pin
  2478.                                 hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pInfTeeOut1);
  2479.                                 if (SUCCEEDED(hr))
  2480.                                 {
  2481.                                     ASSERT(pInfTeeOut1);
  2482.                                     hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pDvIn);
  2483.                                     if (SUCCEEDED(hr))
  2484.                                     {
  2485.                                         ASSERT(pDvIn);
  2486.                                         hr = g_pGraphBuilder->ConnectDirect(pInfTeeOut1, pDvIn, NULL);
  2487.                                         //
  2488.                                         //the capture portion of the graph is built, now lets do the preview
  2489.                                         //
  2490.                                         //get another output pin on the inftee
  2491.                                         hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pInfTeeOut2);
  2492.                                         if (SUCCEEDED(hr))
  2493.                                         {
  2494.                                             // Add the filters DV Splitter, DV Decoder, Video Renderer 
  2495.                                             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVSplitter, L"DV Splitter"));
  2496.                                             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVCodec, L"DV Codec"));
  2497.                                             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pVideoRenderer, L"VideoRenderer"));
  2498.  
  2499.                                             // Find input pin of dvsplitter & connect inf tee and dvsplitter
  2500.                                             hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitIn);
  2501.                                             if (SUCCEEDED(hr))
  2502.                                             {
  2503.                                                 hr = g_pGraphBuilder->ConnectDirect(pInfTeeOut2, pSplitIn, NULL);
  2504.                                                 if (SUCCEEDED(hr))
  2505.                                                 {
  2506.                                                     // find the vid & aud output pins on the dvsplitter
  2507.                                                     hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL , &MEDIATYPE_Video, TRUE, 0, &pSplitVout);
  2508.                                                     if (SUCCEEDED(hr))
  2509.                                                     {
  2510.                                                         hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL , &MEDIATYPE_Audio, TRUE, 0, &pSplitAout);
  2511.                                                         if (SUCCEEDED(hr))
  2512.                                                         {
  2513.                                                             // find the input & output pins on the dv codec
  2514.                                                             hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pCodecIn);
  2515.                                                             if (SUCCEEDED(hr))
  2516.                                                             {
  2517.                                                                 hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_OUTPUT, NULL , NULL, TRUE, 0, &pCodecOut);
  2518.                                                                 if (SUCCEEDED(hr))
  2519.                                                                 {
  2520.                                                                     // connect the dvsplitter(vid) & dvcodec
  2521.                                                                     hr = g_pGraphBuilder->ConnectDirect(pSplitVout, pCodecIn, NULL);
  2522.                                                                     if (SUCCEEDED(hr))
  2523.                                                                     {
  2524.                                                                         //if we have audio, add the filter to the graph connect it to the dvsplitter(aud)
  2525.                                                                         if (g_pDSound)
  2526.                                                                         {
  2527.                                                                             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDSound, L"DSound"));
  2528.                                                                             hr = g_pBuilder->FindPin(g_pDSound, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pAudIn);
  2529.                                                                             if (SUCCEEDED(hr))
  2530.                                                                             {
  2531.                                                                                 hr = g_pGraphBuilder->ConnectDirect(pSplitAout, pAudIn, NULL);
  2532.                                                                             } 
  2533.                                                                         } 
  2534.                                                                         if (SUCCEEDED(hr)) //verifies audio connection when audio exists
  2535.                                                                         {
  2536.                                                                             // get the input pin on the video renderer and connect it to the dvcodec
  2537.                                                                             hr = g_pBuilder->FindPin(g_pVideoRenderer, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pRenderIn);
  2538.                                                                             if (SUCCEEDED(hr))
  2539.                                                                             {
  2540.                                                                                 hr = g_pGraphBuilder->ConnectDirect(pCodecOut, pRenderIn, NULL);
  2541.                                                                                 if (SUCCEEDED(hr))
  2542.                                                                                 {
  2543.                                                                                     // Woohoo! succeeded all the way
  2544.                                                                                     // Set up the Video Window
  2545.                                                                                     if (g_pVideoWindow)
  2546.                                                                                     {
  2547.                                                                                         g_pVideoWindow->put_Owner(NULL);
  2548.                                                                                         SAFE_RELEASE(g_pVideoWindow);
  2549.                                                                                     } 
  2550.                                                                                     hr = g_pBuilder->FindInterface(NULL, &MEDIATYPE_Video, g_pInputFileFilter, IID_IVideoWindow, reinterpret_cast<PVOID *>(&g_pVideoWindow));
  2551.                                                                                     if (SUCCEEDED(hr))
  2552.                                                                                     {
  2553.                                                                                        
  2554.                                                                                         RECT rc, rect;
  2555.                                                                                         g_pVideoWindow->put_Owner((LONG_PTR)g_hwndApp);     // We own the window now
  2556.                                                                                         g_pVideoWindow->put_WindowStyle(WS_CHILD);     // you are now a child
  2557.                                                                                         GetClientRect(g_hwndApp, &rc);
  2558.                                                                                         GetWindowRect(g_hwndTBar, &rect);
  2559.                                                                                         g_pVideoWindow->SetWindowPosition(0, rect.bottom - rect.top, g_iVWWidth, g_iVWHeight);
  2560.                                                                                         g_pVideoWindow->put_Visible(OATRUE);
  2561.                                                                                     }
  2562.                                                                                     else
  2563.                                                                                     {
  2564.                                                                                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("FindInterface (IVideoWindow) Failed. hr = 0x%x"), hr);
  2565.                                                                                     }
  2566.                                                                                 } 
  2567.                                                                                 SAFE_RELEASE(pRenderIn);
  2568.                                                                             } 
  2569.                                                                             SAFE_RELEASE(pAudIn);
  2570.                                                                         } 
  2571.                                                                     } 
  2572.                                                                     SAFE_RELEASE(pCodecOut);
  2573.                                                                 } 
  2574.                                                                 SAFE_RELEASE(pCodecIn);
  2575.                                                             } 
  2576.                                                             SAFE_RELEASE(pSplitAout);
  2577.                                                         } 
  2578.                                                         SAFE_RELEASE(pSplitVout);
  2579.                                                     } 
  2580.                                                 } 
  2581.                                                 SAFE_RELEASE(pSplitIn);
  2582.                                             } 
  2583.                                             SAFE_RELEASE(pInfTeeOut2);
  2584.                                         }   
  2585.                                         SAFE_RELEASE(pDvIn);
  2586.                                     }
  2587.                                     SAFE_RELEASE(pInfTeeOut1);
  2588.                                 }
  2589.                             }
  2590.                             SAFE_RELEASE(pInfTeeIn);
  2591.                         } 
  2592.                         SAFE_RELEASE(pSplitterOut);
  2593.                     } 
  2594.                 } // Release interfaces appropriately
  2595.                 else
  2596.                 {
  2597.                     // Handler for invalid source file format
  2598.                     if (VFW_E_INVALID_FILE_FORMAT == hr)
  2599.                     {
  2600.                         MBOX(TEXT("The File format is invalid for the input file"));
  2601.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("The File format is invalid for the input file"));
  2602.                     } 
  2603.                     else
  2604.                     {
  2605.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from file (0x%x)"), hr);
  2606.                     } 
  2607.                 }
  2608.                 SAFE_RELEASE(pSplitterIn);
  2609.             } 
  2610.             SAFE_RELEASE(pFileOut);
  2611.         } 
  2612.     }
  2613.  
  2614.     //if something failed, remove all of the filters we could have added here, 
  2615.     //because DV_DisconnectAll only removes connected filters
  2616.     if (FAILED(hr))
  2617.     {
  2618.         if (g_pAviSplitter)
  2619.             g_pGraphBuilder->RemoveFilter(g_pAviSplitter);
  2620.         if (g_pInfTee)
  2621.             g_pGraphBuilder->RemoveFilter(g_pInfTee);
  2622.         if (g_pDVSplitter)
  2623.             g_pGraphBuilder->RemoveFilter(g_pDVSplitter);
  2624.         if (g_pDVCodec)
  2625.             g_pGraphBuilder->RemoveFilter(g_pDVCodec);
  2626.         if (g_pVideoRenderer)
  2627.             g_pGraphBuilder->RemoveFilter(g_pVideoRenderer);
  2628.         if (g_pDSound)
  2629.             g_pGraphBuilder->RemoveFilter(g_pDSound);
  2630.         if (g_pInputFileFilter)
  2631.             g_pGraphBuilder->RemoveFilter(g_pInputFileFilter);
  2632.     } 
  2633.     
  2634.     return hr;
  2635. } 
  2636.  
  2637.   
  2638. /*---------------------------------------------------------------------------------------------------------
  2639. Routine:        DV_MakeFileToDvGraph_NoPre
  2640. Purpose:        Builds and runs the File to DV graph without preview
  2641. Arguments:    None
  2642. Returns:        HRESULT as apropriate
  2643. Notes:          This is a transmit only graph for DV Type 1 AVI files           
  2644.                     This graph is a bit simplex.  It looks like this:
  2645.                     FileSource->AVI_Splitter->DV_Camera
  2646. ---------------------------------------------------------------------------------------------------------*/
  2647. HRESULT DV_MakeFileToDvGraph_NoPre(void)
  2648. {
  2649.     HRESULT hr = S_OK;
  2650.     // making sure there is a input file selected
  2651.     if (NULL == g_InputFileName[0])
  2652.     {
  2653.         MBOX(TEXT("Please set an input file for rendering"));
  2654.         hr = E_FAIL;
  2655.     } 
  2656.     else
  2657.     {
  2658.         //if we are compiling ANSI, the file name needs to be converted to UNICODE
  2659.         // Add the file as source filter to the graph
  2660. #ifndef UNICODE
  2661.         WCHAR wFileName[MAX_PATH];
  2662.         MultiByteToWideChar(CP_ACP, 0, g_InputFileName, -1, wFileName, MAX_PATH);
  2663.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(wFileName, wFileName, &g_pInputFileFilter));
  2664. #else
  2665.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(g_InputFileName, g_InputFileName, &g_pInputFileFilter));
  2666. #endif
  2667.         //making sure the file source exists
  2668.         if(g_pInputFileFilter == NULL)
  2669.         {
  2670.             MBOX(TEXT("Please set a correct input file for rendering"));
  2671.             hr = E_FAIL;
  2672.             return hr;
  2673.         } 
  2674.         // Also add the AVI Splitter
  2675.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pAviSplitter, L"AVI Splitter"));
  2676.  
  2677.         // now we need to connect the pins
  2678.         IPin *pFileOut = NULL, *pSplitterIn = NULL, *pSplitterOut = NULL, *pDvIn = NULL;
  2679.  
  2680.         // obtain the output pin of the source filter and connect it to avi splitter
  2681.         hr = g_pBuilder->FindPin(g_pInputFileFilter, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pFileOut);
  2682.         if (SUCCEEDED(hr))
  2683.         {
  2684.             ASSERT(pFileOut);
  2685.             //now get the input pin of the splitter
  2686.             hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitterIn);
  2687.             if (SUCCEEDED(hr))
  2688.             {
  2689.                 ASSERT(pSplitterIn);
  2690.                 //connect the file output pin to the AVI splitter in
  2691.                 //until we do this, the output pin on the splitter won't appear
  2692.                 hr = g_pGraphBuilder->ConnectDirect(pFileOut, pSplitterIn, NULL);
  2693.                 if (SUCCEEDED(hr))
  2694.                 {
  2695.                     //get the AVI Splitter output pin, and the DV Camera input pin and connect them
  2696.                     hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pSplitterOut);
  2697.                     if (SUCCEEDED(hr))
  2698.                     {
  2699.                         hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pDvIn);
  2700.                         if (SUCCEEDED(hr))
  2701.                         {
  2702.                             ASSERT(pDvIn);
  2703.                             hr = g_pGraphBuilder->ConnectDirect(pSplitterOut, pDvIn, NULL);
  2704.                             //
  2705.                             //the capture portion of the graph is built
  2706.                             //
  2707.                             if (FAILED(hr))
  2708.                             {
  2709.                                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_MEDIUM, TEXT("Could not connect the AviSplitter to the DV Camera"));
  2710.                             } 
  2711.                             SAFE_RELEASE(pDvIn);
  2712.                         } 
  2713.                     SAFE_RELEASE(pSplitterOut);
  2714.                     }
  2715.                 } // Release interfaces appropriately
  2716.                 else
  2717.                 {
  2718.                     // Handler for invalid source file format
  2719.                     if (VFW_E_INVALID_FILE_FORMAT == hr)
  2720.                     {
  2721.                         MBOX(TEXT("The File format is invalid for the input file"));
  2722.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("The File format is invalid for the input file"));
  2723.                     } 
  2724.                     else
  2725.                     {
  2726.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from file (0x%x)"), hr);
  2727.                     } 
  2728.                 }
  2729.                 SAFE_RELEASE(pSplitterIn);
  2730.             } 
  2731.             SAFE_RELEASE(pFileOut);
  2732.         } 
  2733.     }
  2734.     //if something failed, remove all of the filters we could have added here, 
  2735.     //because DisconnectAll only removes connected filters
  2736.     if (FAILED(hr))
  2737.     {
  2738.         if (g_pAviSplitter)
  2739.             g_pGraphBuilder->RemoveFilter(g_pAviSplitter);
  2740.         if (g_pInputFileFilter)
  2741.             g_pGraphBuilder->RemoveFilter(g_pInputFileFilter);
  2742.     } 
  2743.     return hr;
  2744. } 
  2745.  
  2746. /*---------------------------------------------------------------------------------------------------------
  2747. Routine:        DV_MakeDvToFileGraph_Type2
  2748. Purpose:        Builds and runs the DV to File graph
  2749. Arguments:    None
  2750. Returns:        HRESULT as apropriate
  2751. Notes:          This is a capture & preview graph for DV Type 2 AVI files           
  2752.                     This graph is a bit more complex.  It looks like this:
  2753.                     DV_Cam(AV Out)->DVSplitter(vid)->SmartTee(capture)->AviMux->FileWriter
  2754.                                                                           SmartTee(preview)->DVCodec->VideoWindow
  2755.                                                 DVSplitter(aud)->InfinitePinTee->AviMux->FileWriter
  2756.                                                                            InfinitePinTee->Default DirectSound device
  2757. ---------------------------------------------------------------------------------------------------------*/
  2758. HRESULT DV_MakeDvToFileGraph_Type2(void)
  2759. {
  2760.     HRESULT hr = S_OK;
  2761.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building DV to File Graph (Adobe)"));
  2762.     // making sure there is a output file selected
  2763.     if (!g_OutputFileName[0])
  2764.     {
  2765.         MBOX(TEXT("Please set up an output file name for recording"));
  2766.         hr = E_FAIL;
  2767.     } 
  2768.     else
  2769.     {
  2770.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("This is the graph - everything should be disconnected"));
  2771. #ifndef UNICODE        
  2772.         // convert the output file name to wchar
  2773.         WCHAR wFileName[MAX_PATH];
  2774.         MultiByteToWideChar(CP_ACP, 0, g_OutputFileName, -1, wFileName, MAX_PATH);
  2775. #endif
  2776.  
  2777.         //we need a lot of pins to make this work...
  2778.         IPin *pAVOut = NULL, *pMuxAIn = NULL, *pMuxVIn = NULL;
  2779.         IPin *pDVSplitterIn = NULL, *pDVSplitterVOut = NULL, *pDVSplitterAOut = NULL;
  2780.         IPin *pTeeIn = NULL, *pTeeOut = NULL, *pTeePreOut = NULL;
  2781.         IPin *pInfTeeIn = NULL, *pInfTeeOut = NULL, *pInfTeePreOut = NULL;
  2782.         IPin *pAudIn = NULL, *pCodecIn = NULL, *pCodecOut = NULL, *pRenderIn = NULL;
  2783.  
  2784.         //get the camera output pin
  2785.         hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_OUTPUT, NULL, &MEDIATYPE_Interleaved, TRUE, 0, &pAVOut);
  2786.         // add the dv splitter, get the input pin of dvsplitter and connect it to the dvcamera
  2787.         if (SUCCEEDED(hr))
  2788.         {
  2789.             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVSplitter, L"DV Splitter"));
  2790.             hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pDVSplitterIn);
  2791.             if(SUCCEEDED(hr))
  2792.             {
  2793.                 hr = g_pGraphBuilder->ConnectDirect(pAVOut, pDVSplitterIn, NULL);
  2794.                 if(SUCCEEDED(hr))
  2795.                 {
  2796.                     // get the vid & aud output pins of the dvsplitter
  2797.                     hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Video, TRUE, 0, &pDVSplitterVOut);
  2798.                     hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Audio, TRUE, 0, &pDVSplitterAOut);
  2799.  
  2800.                     if (SUCCEEDED(hr))
  2801.                     {
  2802.                         ASSERT(pDVSplitterVOut);
  2803.                         ASSERT(pDVSplitterAOut);
  2804.                         //add the smart tee, infinite tee filters to the graph
  2805.                         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pSmartTee, L"Smart Tee"));
  2806.                         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pInfTee, L"Infinite Tee"));
  2807.  
  2808.                         // get the input pin of infinite pin tee and connect it to dvsplitter (aud) output pin
  2809.                         hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pInfTeeIn);
  2810.                         if (SUCCEEDED(hr))
  2811.                         {
  2812.                             hr = g_pGraphBuilder->ConnectDirect(pDVSplitterAOut, pInfTeeIn, NULL);
  2813.                             if (SUCCEEDED(hr))
  2814.                             {
  2815.                                 // get the outpin of infinite pin tee
  2816.                                 hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pInfTeeOut);
  2817.                                 if(SUCCEEDED(hr))
  2818.                                 {          
  2819.                                     // get the input pin of smart tee and connect it to dvsplitter (vid) output pin
  2820.                                     hr = g_pBuilder->FindPin(g_pSmartTee, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pTeeIn);
  2821.                                     if (SUCCEEDED(hr))
  2822.                                     {
  2823.                                         hr = g_pGraphBuilder->ConnectDirect(pDVSplitterVOut, pTeeIn, NULL);
  2824.                                         if (SUCCEEDED(hr))
  2825.                                         {
  2826.                                             // get the capture outpin of smart tee filter and connect it to avi muxer & file writer
  2827.                                             hr = g_pBuilder->FindPin(g_pSmartTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pTeeOut);
  2828.                                             if(SUCCEEDED(hr))
  2829.                                             {
  2830.                                                 //add the avimux, and file writer to the graph 
  2831.                                                 IBaseFilter *ppf = NULL;
  2832.                                                 IFileSinkFilter *pSink = NULL;
  2833. #ifndef UNICODE
  2834.                                                 hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, wFileName, &ppf, &pSink);
  2835. #else
  2836.                                                 hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, g_OutputFileName, &ppf, &pSink);
  2837. #endif //UNICODE
  2838.                                                 if (SUCCEEDED(hr))
  2839.                                                 {
  2840.                                                     // Set the AVI Options like interleaving mode etc...
  2841.                                                     DV_SetAviOptions(ppf, INTERLEAVE_NONE);
  2842.                                                     //Now I need the input video pin on the mux to connect to the file writer
  2843.                                                     hr = g_pBuilder->FindPin(ppf, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxVIn);
  2844.                                                     if (SUCCEEDED(hr))
  2845.                                                     {
  2846.                                                         hr = g_pGraphBuilder->ConnectDirect(pTeeOut, pMuxVIn, NULL);
  2847.                                                         if (SUCCEEDED(hr))
  2848.                                                         {
  2849.                                                             //Now I need the input audio pin on the mux
  2850.                                                             hr = g_pBuilder->FindPin(ppf, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxAIn);
  2851.                                                             if (SUCCEEDED(hr))
  2852.                                                             {
  2853.                                                                 hr = g_pGraphBuilder->ConnectDirect(pInfTeeOut, pMuxAIn, NULL);
  2854.                                                                 //  
  2855.                                                                 //the capture graph is built,but we still need to build the preview graph
  2856.                                                                 //
  2857.                                                                 // get the preview output pin on the smart tee
  2858.                                                                 hr = g_pBuilder->FindPin(g_pSmartTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pTeePreOut);
  2859.                                                                 if (SUCCEEDED(hr))
  2860.                                                                 {
  2861.                                                                     // Add the filters DV Decoder, Video Renderer 
  2862.                                                                     EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVCodec, L"DV Codec"));
  2863.                                                                     EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pVideoRenderer, L"VideoRenderer"));
  2864.  
  2865.                                                                     // get the output pin of Infinite pin tee filter
  2866.                                                                     hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_OUTPUT, NULL , NULL, TRUE, 0, &pInfTeePreOut);
  2867.                                                                     if (SUCCEEDED(hr))
  2868.                                                                     {
  2869.                                                                         // find the input & output pins on the dv codec
  2870.                                                                         hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pCodecIn);
  2871.                                                                         if (SUCCEEDED(hr))
  2872.                                                                         {
  2873.                                                                             hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_OUTPUT, NULL , NULL, TRUE, 0, &pCodecOut);
  2874.                                                                             if (SUCCEEDED(hr))
  2875.                                                                             {
  2876.                                                                                 // connect the infinite pin tee to dvcodec 
  2877.                                                                                 hr = g_pGraphBuilder->ConnectDirect(pTeePreOut, pCodecIn, NULL);
  2878.                                                                                 if (SUCCEEDED(hr))
  2879.                                                                                 {
  2880.                                                                                     //if we have audio, add the filter to the graph connect it to the infinite pin tee
  2881.                                                                                     if (g_pDSound)
  2882.                                                                                     {
  2883.                                                                                         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDSound, L"DSound"));
  2884.                                                                                         hr = g_pBuilder->FindPin(g_pDSound, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pAudIn);
  2885.                                                                                         if (SUCCEEDED(hr))
  2886.                                                                                         {
  2887.                                                                                             hr = g_pGraphBuilder->ConnectDirect(pInfTeePreOut, pAudIn, NULL);
  2888.                                                                                             SAFE_RELEASE(pAudIn);
  2889.                                                                                         }
  2890.                                                                                     }   
  2891.                                                                                     if (SUCCEEDED(hr))  //this verifies success of the audio connection when audio exists
  2892.                                                                                     {
  2893.                                                                                         // get the input pin ont he video renderer and connect it to the dvcodec
  2894.                                                                                         hr = g_pBuilder->FindPin(g_pVideoRenderer, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pRenderIn);
  2895.                                                                                         if (SUCCEEDED(hr))
  2896.                                                                                         {
  2897.                                                                                             hr = g_pGraphBuilder->ConnectDirect(pCodecOut, pRenderIn, NULL);
  2898.                                                                                             if (SUCCEEDED(hr))
  2899.                                                                                             {
  2900.                                                                                                 // Woohoo! succeeded all the way
  2901.                                                                                                 // Set the Filter Graph to Preview State (Run in this case)
  2902.                                                                                                 DV_SetPreview();
  2903.                                                                                             } 
  2904.                                                                                         } 
  2905.                                                                                         SAFE_RELEASE(pRenderIn);
  2906.                                                                                     } 
  2907.                                                                                 } 
  2908.                                                                             } 
  2909.                                                                             SAFE_RELEASE(pCodecOut);
  2910.                                                                         } 
  2911.                                                                         SAFE_RELEASE(pCodecIn);
  2912.                                                                     } 
  2913.                                                                     SAFE_RELEASE(pInfTeePreOut);
  2914.                                                                 } 
  2915.                                                                 SAFE_RELEASE(pTeePreOut);
  2916.                                                             } 
  2917.                                                             SAFE_RELEASE(pMuxAIn);
  2918.                                                         } 
  2919.                                                     } 
  2920.                                                     SAFE_RELEASE(pMuxVIn);
  2921.                                                 }
  2922.                                                 SAFE_RELEASE(ppf);
  2923.                                                 SAFE_RELEASE(pSink);
  2924.                                             }
  2925.                                             SAFE_RELEASE(pTeeOut);
  2926.                                         } 
  2927.                                     }
  2928.                                     SAFE_RELEASE(pTeeIn);
  2929.                                 }
  2930.                                 SAFE_RELEASE(pInfTeeOut);
  2931.                             }
  2932.                         }
  2933.                         SAFE_RELEASE(pInfTeeIn);
  2934.                     }
  2935.                     SAFE_RELEASE(pDVSplitterVOut);
  2936.                     SAFE_RELEASE(pDVSplitterAOut);
  2937.                 } // Release interfaces appropriately
  2938.                 else
  2939.                 {
  2940.                     DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect output pin from camera (0x%x)"), hr);
  2941.                 } 
  2942.             } 
  2943.             SAFE_RELEASE(pDVSplitterIn);
  2944.         } 
  2945.         SAFE_RELEASE(pAVOut);
  2946.     }
  2947.     return hr;
  2948. }
  2949.  
  2950. /*---------------------------------------------------------------------------------------------------------
  2951. Routine:        DV_MakeDvToFileGraph_NoPre_Type2
  2952. Purpose:        Builds and runs the DV to File graph
  2953. Arguments:    None
  2954. Returns:        HRESULT as apropriate
  2955. Notes:          This is a capture only graph for DV Type 2 AVI files            
  2956.                     This graph is a bit simplex .  It looks like this:
  2957.                     DV_Cam(AV Out)->DVSplitter(vid)->AviMux->FileWriter
  2958.                                                 DVSplitter(aud)->AviMux->FileWriter
  2959. ---------------------------------------------------------------------------------------------------------*/
  2960. HRESULT DV_MakeDvToFileGraph_NoPre_Type2(void)
  2961. {
  2962.     HRESULT hr = S_OK;
  2963.     DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Building DV to File Graph (No Preview)"));
  2964.     // making sure there is a output file selected
  2965.     if (!g_OutputFileName[0])
  2966.     {
  2967.         MBOX(TEXT("Please set up an output file name for recording"));
  2968.         hr = E_FAIL;
  2969.     } 
  2970.     else
  2971.     {
  2972.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_VERBOSE, TEXT("This is the graph - everything should be disconnected"));
  2973. #ifndef UNICODE        
  2974.         // convert the output file name to wchar
  2975.         WCHAR wFileName[MAX_PATH];
  2976.         MultiByteToWideChar(CP_ACP, 0, g_OutputFileName, -1, wFileName, MAX_PATH);
  2977. #endif
  2978.  
  2979.         //we'll need a few pins...
  2980.         IPin *pAVOut = NULL, *pDVSplitterIn=NULL, *pDVSplitterVOut=NULL, *pDVSplitterAOut=NULL, *pMuxVIn = NULL, *pMuxAIn = NULL;
  2981.  
  2982.         //get the camera output pin
  2983.         hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_OUTPUT, NULL, &MEDIATYPE_Interleaved, TRUE, 0, &pAVOut);
  2984.         // add the dv splitter, get the input pin of dvsplitter and connect it to the dvcamera
  2985.         if(SUCCEEDED(hr))
  2986.         {
  2987.             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVSplitter, L"DV Splitter"));
  2988.             hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pDVSplitterIn);
  2989.             if(SUCCEEDED(hr))
  2990.             {
  2991.                 hr = g_pGraphBuilder->ConnectDirect(pAVOut, pDVSplitterIn, NULL);
  2992.                 if(SUCCEEDED(hr))
  2993.                 {
  2994.                     // get the vid & aud output pins of the dvsplitter
  2995.                     hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Video, TRUE, 0, &pDVSplitterVOut);
  2996.                     hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Audio, TRUE, 0, &pDVSplitterAOut);
  2997.                     if (SUCCEEDED(hr))
  2998.                     {
  2999.                         ASSERT(pDVSplitterVOut);
  3000.                         ASSERT(pDVSplitterAOut);
  3001.                         //add the avimux, and file writer to the graph 
  3002.                         IBaseFilter *ppf = NULL;
  3003.                         IFileSinkFilter *pSink = NULL;
  3004. #ifndef UNICODE
  3005.                         hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, wFileName, &ppf, &pSink);
  3006. #else
  3007.                         hr = g_pBuilder->SetOutputFileName(&MEDIASUBTYPE_Avi, g_OutputFileName, &ppf, &pSink);
  3008. #endif //UNICODE
  3009.                         if (SUCCEEDED(hr))
  3010.                         {
  3011.                             // Set the AVI Options like interleaving mode etc...
  3012.                             DV_SetAviOptions(ppf, INTERLEAVE_NONE);
  3013.                             //Now I need the input pin on the mux to connect to the file writer
  3014.                             hr = g_pBuilder->FindPin(ppf, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxVIn);
  3015.                             // connect the video & audio paths between dvsplitter & avi muxer
  3016.                             if (SUCCEEDED(hr))
  3017.                             {
  3018.                                 hr = g_pGraphBuilder->ConnectDirect(pDVSplitterVOut, pMuxVIn, NULL);
  3019.                                 if(SUCCEEDED(hr))
  3020.                                 {
  3021.                                     hr = g_pBuilder->FindPin(ppf, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxAIn);
  3022.                                     if(SUCCEEDED(hr))
  3023.                                     {
  3024.                                         hr = g_pGraphBuilder->ConnectDirect(pDVSplitterAOut, pMuxAIn, NULL);
  3025.                                         //  
  3026.                                         //the capture graph is built
  3027.                                         //
  3028.                                         if (FAILED(hr))
  3029.                                         {
  3030.                                             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from camera (0x%x)"), hr);
  3031.                                         }                                       
  3032.                                                             
  3033.                                         SAFE_RELEASE(pMuxAIn);
  3034.                                     }
  3035.                                 }
  3036.                                 SAFE_RELEASE(pMuxVIn);
  3037.                             }
  3038.                             SAFE_RELEASE(ppf);
  3039.                             SAFE_RELEASE(pSink);
  3040.                         } 
  3041.             
  3042.                     }
  3043.                     SAFE_RELEASE(pDVSplitterVOut);
  3044.                     SAFE_RELEASE(pDVSplitterAOut);
  3045.                 }
  3046.             }
  3047.             SAFE_RELEASE(pDVSplitterIn);
  3048.         }
  3049.         SAFE_RELEASE(pAVOut);
  3050.     } // Release interfaces appropriately
  3051.     return hr;
  3052. } 
  3053.  
  3054. /*---------------------------------------------------------------------------------------------------------
  3055. Routine:        DV_MakeFileToDvGraph_Type2
  3056. Purpose:        Builds and runs the File to DV graph 
  3057. Arguments:    None
  3058. Returns:        HRESULT as apropriate
  3059. Notes:          This is a transmit & playback graph for DV Type 2 AVI files         
  3060.                     This graph is a bit complex.  It looks like this:
  3061.                      FileSource->AVI_Splitter(vid) ->DVMuxer(vid)---------->InfPinTee->DV_Camera
  3062.                                         AVI_Splitter(aud)->DVMuxer(aud)                 InfPinTee->DVSplitter(vid)->DVDecoder->VideoWIndow
  3063.                                                                                                                                             DVSplitter(aud)->DSoundDevice
  3064. ---------------------------------------------------------------------------------------------------------*/
  3065. HRESULT DV_MakeFileToDvGraph_Type2(void)
  3066. {
  3067.     HRESULT hr = S_OK;
  3068.     // making sure there is a input file selected
  3069.     if (NULL == g_InputFileName[0])
  3070.     {
  3071.         MBOX(TEXT("Please set an input file for rendering"));
  3072.         hr = E_FAIL;
  3073.     } 
  3074.     else
  3075.     {
  3076.         //if we are compiling ANSI, the file name needs to be converted to UNICODE
  3077.         // Add the file as source filter to the graph
  3078. #ifndef UNICODE
  3079.         WCHAR wFileName[MAX_PATH];
  3080.         MultiByteToWideChar(CP_ACP, 0, g_InputFileName, -1, wFileName, MAX_PATH);
  3081.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(wFileName, wFileName, &g_pInputFileFilter));
  3082. #else
  3083.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(g_InputFileName, g_InputFileName, &g_pInputFileFilter));
  3084. #endif
  3085.         //making sure the file source exists
  3086.         if(g_pInputFileFilter == NULL)
  3087.         {
  3088.             MBOX(TEXT("Please set a correct input file for rendering"));
  3089.             hr = E_FAIL;
  3090.             return hr;
  3091.         } 
  3092.         // Also add the AVI Splitter
  3093.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pAviSplitter, L"AVI Splitter"));
  3094.  
  3095.         // now we need to connect the pins
  3096.         IPin *pFileOut = NULL, *pSplitterIn = NULL, *pSplitterVOut = NULL, *pSplitterAOut = NULL, *pDvIn = NULL;
  3097.         IPin *pInfTeeIn = NULL, *pInfTeeOut1 = NULL, *pInfTeeOut2 = NULL, *pSplitIn = NULL, *pRenderIn = NULL;
  3098.         IPin *pSplitVout = NULL, *pSplitAout = NULL, *pCodecIn = NULL, *pCodecOut = NULL, *pAudIn = NULL;
  3099.         IPin *pMuxerVIn = NULL, *pMuxerAIn = NULL, *pMuxerOut = NULL;
  3100.  
  3101.         // obtain the output pin of the source filter and connect it to avi splitter
  3102.         hr = g_pBuilder->FindPin(g_pInputFileFilter, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pFileOut);
  3103.         if (SUCCEEDED(hr))
  3104.         {
  3105.             ASSERT(pFileOut);
  3106.             //now get the input pin of the splitter
  3107.             hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitterIn);
  3108.             if (SUCCEEDED(hr))
  3109.             {
  3110.                 ASSERT(pSplitterIn);
  3111.                 //connect the file output pin to the AVI splitter in
  3112.                 //until we do this, the output pin on the splitter won't appear
  3113.                 hr = g_pGraphBuilder->ConnectDirect(pFileOut, pSplitterIn, NULL);
  3114.                 if (SUCCEEDED(hr))
  3115.                 {
  3116.                     // get the video & audio output pins of the avi splitter
  3117.                     hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Video, TRUE, 0, &pSplitterVOut);
  3118.                     hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Audio, TRUE, 0, &pSplitterAOut);
  3119.                     if(SUCCEEDED(hr))
  3120.                     {
  3121.                         ASSERT(pSplitterVOut);
  3122.                         ASSERT(pSplitterAOut);
  3123.                         // Add the DVMuxer to the graph
  3124.                         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVMux, L"DV Muxer"));
  3125.                         // get the video & audio input pins on the dvmuxer and connect it to the corressponding output pins of avi splitter
  3126.                         hr = g_pBuilder->FindPin(g_pDVMux, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxerVIn);
  3127.                         if(SUCCEEDED(hr))
  3128.                         {
  3129.                             hr = g_pGraphBuilder->ConnectDirect(pSplitterVOut, pMuxerVIn, NULL);
  3130.                             if(SUCCEEDED(hr))
  3131.                             {
  3132.                                 hr = g_pBuilder->FindPin(g_pDVMux, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxerAIn);
  3133.                                 if(SUCCEEDED(hr))
  3134.                                 {
  3135.                                     hr = g_pGraphBuilder->ConnectDirect(pSplitterAOut, pMuxerAIn, NULL);
  3136.                                     // get the ouput pin of the dv muxer
  3137.                                     if(SUCCEEDED(hr))
  3138.                                     {
  3139.                                         hr = g_pBuilder->FindPin(g_pDVMux, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pMuxerOut);
  3140.                                         if (SUCCEEDED(hr))
  3141.                                         {
  3142.                                             //Add the infinite pin tee filter to the graph and connect it downstream to the dv muxer
  3143.                                             EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pInfTee, L"Infinite Tee")); 
  3144.                                             hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pInfTeeIn);
  3145.                                             if (SUCCEEDED(hr))
  3146.                                             {
  3147.                                                 ASSERT(pInfTeeIn);
  3148.                                                 hr = g_pGraphBuilder->ConnectDirect(pMuxerOut, pInfTeeIn, NULL);
  3149.                                                 if (SUCCEEDED(hr))
  3150.                                                 {
  3151.                                                     //get the inftee output pin, and the DV Camera input pin and connect them
  3152.                                                     hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pInfTeeOut1);
  3153.                                                     if (SUCCEEDED(hr))
  3154.                                                     {
  3155.                                                         ASSERT(pInfTeeOut1);
  3156.                                                         hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pDvIn);
  3157.                                                         if (SUCCEEDED(hr))
  3158.                                                         {
  3159.                                                             ASSERT(pDvIn);
  3160.                                                             hr = g_pGraphBuilder->ConnectDirect(pInfTeeOut1, pDvIn, NULL);
  3161.                                                             //
  3162.                                                             //the capture portion of the graph should be done now, lets do the preview segment
  3163.                                                             //
  3164.                                                             //get another output pin on the inftee
  3165.                                                             hr = g_pBuilder->FindPin(g_pInfTee, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pInfTeeOut2);
  3166.                                                             if (SUCCEEDED(hr))
  3167.                                                             {
  3168.                                                                 // Add the filters DV Splitter, DV Decoder, Video Renderer 
  3169.                                                                 EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVSplitter, L"DV Splitter"));
  3170.                                                                 EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVCodec, L"DV Codec"));
  3171.                                                                 EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pVideoRenderer, L"VideoRenderer"));
  3172.                                            
  3173.                                                                 // Find input pin of dvsplitter & connect inf tee and dvsplitter
  3174.                                                                 hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitIn);
  3175.                                                                 if (SUCCEEDED(hr))
  3176.                                                                 {
  3177.                                                                     hr = g_pGraphBuilder->ConnectDirect(pInfTeeOut2, pSplitIn, NULL);
  3178.                                                                     if (SUCCEEDED(hr))
  3179.                                                                     {
  3180.                                                                         // find the vid & aud output pins on the dvsplitter
  3181.                                                                         hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL , &MEDIATYPE_Video, TRUE, 0, &pSplitVout);
  3182.                                                                         if (SUCCEEDED(hr))
  3183.                                                                         {
  3184.                                                                             hr = g_pBuilder->FindPin(g_pDVSplitter, PINDIR_OUTPUT, NULL , &MEDIATYPE_Audio, TRUE, 0, &pSplitAout);
  3185.                                                                             if (SUCCEEDED(hr))
  3186.                                                                             {
  3187.                                                                                 // find the input & output pins on the dv codec
  3188.                                                                                 hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pCodecIn);
  3189.                                                                                 if (SUCCEEDED(hr))
  3190.                                                                                 {
  3191.                                                                                     hr = g_pBuilder->FindPin(g_pDVCodec, PINDIR_OUTPUT, NULL , NULL, TRUE, 0, &pCodecOut);
  3192.                                                                                     if (SUCCEEDED(hr))
  3193.                                                                                     {
  3194.                                                                                         // connect the dvsplitter(vid) & dvcodec
  3195.                                                                                         hr = g_pGraphBuilder->ConnectDirect(pSplitVout, pCodecIn, NULL);
  3196.                                                                                         if (SUCCEEDED(hr))
  3197.                                                                                         {
  3198.                                                                                             //if we have audio, add the filter to the graph connect it to the dvsplitter(aud)
  3199.                                                                                             if (g_pDSound)
  3200.                                                                                             {
  3201.                                                                                                 EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDSound, L"DSound"));
  3202.                                                                                                 hr = g_pBuilder->FindPin(g_pDSound, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pAudIn);
  3203.                                                                                                 if (SUCCEEDED(hr))
  3204.                                                                                                 {
  3205.                                                                                                     hr = g_pGraphBuilder->ConnectDirect(pSplitAout, pAudIn, NULL);
  3206.                                                                                                 } 
  3207.                                                                                             } 
  3208.                                                                                             if (SUCCEEDED(hr)) //verifies audio connection when audio exists
  3209.                                                                                             {
  3210.                                                                                                 // get the input pin on the video renderer and connect it to the dvcodec
  3211.                                                                                                 hr = g_pBuilder->FindPin(g_pVideoRenderer, PINDIR_INPUT, NULL , NULL, TRUE, 0, &pRenderIn);
  3212.                                                                                                 if (SUCCEEDED(hr))
  3213.                                                                                                 {
  3214.                                                                                                     hr = g_pGraphBuilder->ConnectDirect(pCodecOut, pRenderIn, NULL);
  3215.                                                                                                     if (SUCCEEDED(hr))
  3216.                                                                                                     {
  3217.                                                                                                         // Woohoo! succeeded all the way
  3218.                                                                                                         // Set up the Video Window
  3219.                                                                                                         if (g_pVideoWindow)
  3220.                                                                                                         {
  3221.                                                                                                             g_pVideoWindow->put_Owner(NULL);
  3222.                                                                                                             SAFE_RELEASE(g_pVideoWindow);
  3223.                                                                                                         } 
  3224.                                                                                                         hr = g_pBuilder->FindInterface(NULL, &MEDIATYPE_Video, g_pInputFileFilter, IID_IVideoWindow, reinterpret_cast<PVOID *>(&g_pVideoWindow));
  3225.                                                                                                         if (SUCCEEDED(hr))
  3226.                                                                                                         {
  3227.                                                                                        
  3228.                                                                                                             RECT rc, rect;
  3229.                                                                                                             g_pVideoWindow->put_Owner((LONG_PTR)g_hwndApp);     // We own the window now
  3230.                                                                                                             g_pVideoWindow->put_WindowStyle(WS_CHILD);     // you are now a child
  3231.                                                                                                             GetClientRect(g_hwndApp, &rc);
  3232.                                                                                                             GetWindowRect(g_hwndTBar, &rect);
  3233.                                                                                                             g_pVideoWindow->SetWindowPosition(0, rect.bottom - rect.top, g_iVWWidth, g_iVWHeight);
  3234.                                                                                                             g_pVideoWindow->put_Visible(OATRUE);
  3235.                                                                                                         }
  3236.                                                                                                         else
  3237.                                                                                                         {
  3238.                                                                                                             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("FindInterface (IVideoWindow) Failed. hr = 0x%x"), hr);
  3239.                                                                                                         }
  3240.                                                                                                     } 
  3241.                                                                                                     SAFE_RELEASE(pRenderIn);
  3242.                                                                                                 } 
  3243.                                                                                                 SAFE_RELEASE(pAudIn);
  3244.                                                                                             } 
  3245.                                                                                         } 
  3246.                                                                                         SAFE_RELEASE(pCodecOut);
  3247.                                                                                     } 
  3248.                                                                                     SAFE_RELEASE(pCodecIn);
  3249.                                                                                 } 
  3250.                                                                                 SAFE_RELEASE(pSplitAout);
  3251.                                                                             } 
  3252.                                                                             SAFE_RELEASE(pSplitVout);
  3253.                                                                         } 
  3254.                                                                     } 
  3255.                                                                     SAFE_RELEASE(pSplitIn);
  3256.                                                                 } 
  3257.                                                                 SAFE_RELEASE(pInfTeeOut2);
  3258.                                                             }   
  3259.                                                             SAFE_RELEASE(pDvIn);
  3260.                                                         }
  3261.                                                         SAFE_RELEASE(pInfTeeOut1);
  3262.                                                     }
  3263.                                                 }
  3264.                                                 SAFE_RELEASE(pInfTeeIn);
  3265.                                             }
  3266.                                             SAFE_RELEASE(pMuxerOut);
  3267.                                         }
  3268.                                     }
  3269.                                     SAFE_RELEASE(pMuxerAIn);
  3270.                                 }
  3271.                             }
  3272.                             SAFE_RELEASE(pMuxerVIn);
  3273.                         } 
  3274.                         SAFE_RELEASE(pSplitterVOut);
  3275.                         SAFE_RELEASE(pSplitterAOut);
  3276.                     } 
  3277.                 } // Release interfaces appropriately
  3278.                 else
  3279.                 {
  3280.                     // Handler for invalid source file format
  3281.                     if (VFW_E_INVALID_FILE_FORMAT == hr)
  3282.                     {
  3283.                         MBOX(TEXT("The File format is invalid for the input file"));
  3284.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("The File format is invalid for the input file"));
  3285.                     } 
  3286.                     else
  3287.                     {
  3288.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from file (0x%x)"), hr);
  3289.                     } 
  3290.                 }
  3291.                 SAFE_RELEASE(pSplitterIn);
  3292.             } 
  3293.             SAFE_RELEASE(pFileOut);
  3294.         } 
  3295.     }
  3296.     //if something failed, remove all of the filters we could have added here, 
  3297.     //because DV_DisconnectAll only removes connected filters
  3298.     if (FAILED(hr))
  3299.     {
  3300.         if (g_pAviSplitter)
  3301.             g_pGraphBuilder->RemoveFilter(g_pAviSplitter);
  3302.         if (g_pInfTee)
  3303.             g_pGraphBuilder->RemoveFilter(g_pInfTee);
  3304.         if (g_pDVSplitter)
  3305.             g_pGraphBuilder->RemoveFilter(g_pDVSplitter);
  3306.         if (g_pDVCodec)
  3307.             g_pGraphBuilder->RemoveFilter(g_pDVCodec);
  3308.         if (g_pVideoRenderer)
  3309.             g_pGraphBuilder->RemoveFilter(g_pVideoRenderer);
  3310.         if (g_pDSound)
  3311.             g_pGraphBuilder->RemoveFilter(g_pDSound);
  3312.         if (g_pInputFileFilter)
  3313.             g_pGraphBuilder->RemoveFilter(g_pInputFileFilter);
  3314.     } 
  3315.     
  3316.     return hr;
  3317. } 
  3318.  
  3319.   
  3320. /*---------------------------------------------------------------------------------------------------------
  3321. Routine:        DV_MakeFileToDvGraph_NoPre_Type2
  3322. Purpose:        Builds and runs the File to DV graph 
  3323. Arguments:    None
  3324. Returns:        HRESULT as apropriate
  3325. Notes:          This is a transmit only graph for DV Type 2 AVI files           
  3326.                     This graph looks like this:
  3327.                      FileSource->AVI_Splitter(vid) ->DVMuxer(vid)----->DV_Camera
  3328.                                         AVI_Splitter(aud)->DVMuxer(aud)                 
  3329. ---------------------------------------------------------------------------------------------------------*/
  3330. HRESULT DV_MakeFileToDvGraph_NoPre_Type2(void)
  3331. {
  3332.     HRESULT hr = S_OK;
  3333.     // making sure there is a input file selected
  3334.     if (NULL == g_InputFileName[0])
  3335.     {
  3336.         MBOX(TEXT("Please set an input file for rendering"));
  3337.         hr = E_FAIL;
  3338.     } 
  3339.     else
  3340.     {
  3341.         //if we are compiling ANSI, the file name needs to be converted to UNICODE
  3342.         // Add the file as source filter to the graph
  3343. #ifndef UNICODE
  3344.         WCHAR wFileName[MAX_PATH];
  3345.         MultiByteToWideChar(CP_ACP, 0, g_InputFileName, -1, wFileName, MAX_PATH);
  3346.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(wFileName, wFileName, &g_pInputFileFilter));
  3347. #else
  3348.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddSourceFilter(g_InputFileName, g_InputFileName, &g_pInputFileFilter));
  3349. #endif
  3350.         //making sure the file source exists
  3351.         if(g_pInputFileFilter == NULL)
  3352.         {
  3353.             MBOX(TEXT("Please set a correct input file for rendering"));
  3354.             hr = E_FAIL;
  3355.             return hr;
  3356.         } 
  3357.         // Also add the AVI Splitter
  3358.         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pAviSplitter, L"AVI Splitter"));
  3359.  
  3360.         // now we need to connect the pins
  3361.         IPin *pFileOut = NULL, *pSplitterIn = NULL, *pSplitterVOut = NULL, *pSplitterAOut = NULL, *pMuxerVIn=NULL, *pMuxerAIn=NULL, *pMuxerOut=NULL, *pDvIn = NULL;
  3362.  
  3363.         // obtain the output pin of the source filter and connect it to avi splitter
  3364.         hr = g_pBuilder->FindPin(g_pInputFileFilter, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pFileOut);
  3365.         if (SUCCEEDED(hr))
  3366.         {
  3367.             ASSERT(pFileOut);
  3368.             //now get the input pin of the splitter
  3369.             hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pSplitterIn);
  3370.             if (SUCCEEDED(hr))
  3371.             {
  3372.                 ASSERT(pSplitterIn);
  3373.                 //connect the file output pin to the AVI splitter in
  3374.                 //until we do this, the output pin on the splitter won't appear
  3375.                 hr = g_pGraphBuilder->ConnectDirect(pFileOut, pSplitterIn, NULL);
  3376.                 if (SUCCEEDED(hr))
  3377.                 {
  3378.                     // get the video & audio output pins of the avi splitter
  3379.                     hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Video, TRUE, 0, &pSplitterVOut);
  3380.                     hr = g_pBuilder->FindPin(g_pAviSplitter, PINDIR_OUTPUT, NULL, &MEDIATYPE_Audio, TRUE, 0, &pSplitterAOut);
  3381.                     if(SUCCEEDED(hr))
  3382.                     {
  3383.                         ASSERT(pSplitterVOut);
  3384.                         ASSERT(pSplitterAOut);
  3385.                         // Add the DVMuxer to the graph
  3386.                         EXECUTE_ASSERT(S_OK == g_pGraphBuilder->AddFilter(g_pDVMux, L"DV Muxer"));
  3387.                         // get the video & audio input pins on the dvmuxer and connect it to the corressponding output pins of avi splitter
  3388.                         hr = g_pBuilder->FindPin(g_pDVMux, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxerVIn);
  3389.                         if(SUCCEEDED(hr))
  3390.                         {
  3391.                             hr = g_pGraphBuilder->ConnectDirect(pSplitterVOut, pMuxerVIn, NULL);
  3392.                             if(SUCCEEDED(hr))
  3393.                             {
  3394.                                 hr = g_pBuilder->FindPin(g_pDVMux, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pMuxerAIn);
  3395.                                 if(SUCCEEDED(hr))
  3396.                                 {
  3397.                                     hr = g_pGraphBuilder->ConnectDirect(pSplitterAOut, pMuxerAIn, NULL);
  3398.                                     // get the ouput pin of the dv muxer and the dv camera input pin and connect them
  3399.                                     if(SUCCEEDED(hr))
  3400.                                     {
  3401.                                         hr = g_pBuilder->FindPin(g_pDVMux, PINDIR_OUTPUT, NULL, NULL, TRUE, 0, &pMuxerOut);
  3402.                                         if(SUCCEEDED(hr))
  3403.                                         {
  3404.                                             hr = g_pBuilder->FindPin(g_pDVCamera, PINDIR_INPUT, NULL, NULL, TRUE, 0, &pDvIn);
  3405.                                             if (SUCCEEDED(hr))
  3406.                                             {
  3407.                                                 ASSERT(pDvIn);
  3408.                                                 hr = g_pGraphBuilder->ConnectDirect(pMuxerOut, pDvIn, NULL);
  3409.                                                 //
  3410.                                                 //the capture portion of the graph should be done now, lets do the preview segment
  3411.                                                 //
  3412.                                                 if (FAILED(hr))
  3413.                                                 {
  3414.                                                     DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_MEDIUM, TEXT("Could not connect the DV Muxer to the DV Camera"));
  3415.                                                 } 
  3416.                                                 SAFE_RELEASE(pDvIn);
  3417.                                             } 
  3418.                                         }
  3419.                                         SAFE_RELEASE(pMuxerOut);
  3420.                                     }
  3421.                                 }
  3422.                                 SAFE_RELEASE(pMuxerAIn);
  3423.                             }
  3424.                         }
  3425.                         SAFE_RELEASE(pMuxerVIn);
  3426.                     }                   
  3427.                     SAFE_RELEASE(pSplitterVOut);
  3428.                     SAFE_RELEASE(pSplitterAOut);
  3429.                 } // Release interfaces appropriately
  3430.                 else
  3431.                 {
  3432.                     // Handler for invalid source file format
  3433.                     if (VFW_E_INVALID_FILE_FORMAT == hr)
  3434.                     {
  3435.                         MBOX(TEXT("The File format is invalid for the input file"));
  3436.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("The File format is invalid for the input file"));
  3437.                     } 
  3438.                     else
  3439.                     {
  3440.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not connect ouput pin from file (0x%x)"), hr);
  3441.                     } 
  3442.                 }
  3443.                 SAFE_RELEASE(pSplitterIn);
  3444.             } 
  3445.             SAFE_RELEASE(pFileOut);
  3446.         } 
  3447.     }
  3448.     //if something failed, remove all of the filters we could have added here, 
  3449.     //because DisconnectAll only removes connected filters
  3450.     if (FAILED(hr))
  3451.     {
  3452.         if (g_pAviSplitter)
  3453.             g_pGraphBuilder->RemoveFilter(g_pAviSplitter);
  3454.         if (g_pInputFileFilter)
  3455.             g_pGraphBuilder->RemoveFilter(g_pInputFileFilter);
  3456.  
  3457.     } 
  3458.     return hr;
  3459. } 
  3460.  
  3461. /*-------------------------------------------------------------------------
  3462. Routine:        DV_SetAviOptions
  3463. Purpose:        Routine for changing AVI Mux properties.  In this sample, we just set a few options.  
  3464.                     These options could be set through the Avi Mux property sheet, or through a separate dialog
  3465. Arguments:    pointer to the AVI renderer (from SetOutputFileName())
  3466. Returns:        HRESULT as appropriate
  3467. Notes:          
  3468. ------------------------------------------------------------------------*/
  3469. HRESULT DV_SetAviOptions(IBaseFilter *ppf, InterleavingMode INTERLEAVE_MODE)
  3470. {
  3471.     HRESULT hr;
  3472.     ASSERT(ppf);
  3473.     IConfigAviMux       *pMux           = NULL;
  3474.     IConfigInterleaving *pInterleaving  = NULL;
  3475.  
  3476.     // QI for interface AVI Muxer
  3477.     hr = ppf->QueryInterface(IID_IConfigAviMux, reinterpret_cast<PVOID *>(&pMux));
  3478.     if (SUCCEEDED(hr))
  3479.     {
  3480.         pMux->SetOutputCompatibilityIndex(TRUE);
  3481.         // QI for interface Interleaving
  3482.         hr = ppf->QueryInterface(IID_IConfigInterleaving, reinterpret_cast<PVOID *>(&pInterleaving));
  3483.         if (SUCCEEDED(hr))
  3484.         {
  3485.             // put the interleaving mode (full, none, half)
  3486.             pInterleaving->put_Mode(INTERLEAVE_MODE);
  3487.             SAFE_RELEASE(pInterleaving);
  3488.         } 
  3489.         SAFE_RELEASE(pMux);
  3490.     } 
  3491.     return hr;
  3492. } 
  3493.  
  3494.  
  3495. /*-------------------------------------------------------------------------
  3496. Routine:        DV_AboutDlgProc
  3497. Purpose:        simple standard about dialog box proc 
  3498. Arguments:    Usual Dialog Processing parameters
  3499. Returns:        BOOL
  3500. Notes:          
  3501. ------------------------------------------------------------------------*/
  3502. BOOL CALLBACK DV_AboutDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  3503. {
  3504.     switch ( msg )
  3505.     {
  3506.     //the only command we process are those that close the dialog   
  3507.         case WM_COMMAND:
  3508.             EndDialog(hwnd, TRUE);
  3509.             return TRUE;
  3510.         case WM_INITDIALOG:
  3511.             return TRUE;
  3512.     }
  3513.     return FALSE;
  3514. }
  3515.  
  3516. /*-------------------------------------------------------------------------
  3517. Routine:        DV_ChooseModeDlgProc
  3518. Purpose:        dialog proc to select camera/vcr mode on devices that do not respond to the queries
  3519. Arguments:    Usual Dialog Processing parameters
  3520. Returns:        BOOL
  3521. Notes:          
  3522. ------------------------------------------------------------------------*/
  3523. BOOL CALLBACK DV_ChooseModeDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  3524. {
  3525.     switch ( msg )
  3526.     {
  3527.         case WM_COMMAND:
  3528.             // Choose whether the camera or vcr unit is selected manually
  3529.             switch LOWORD(wParam)
  3530.             {
  3531.                 case IDC_BUTTON_CAMERA :
  3532.                     g_CurrentMode = CameraMode;
  3533.                     EndDialog(hwnd, TRUE);
  3534.                     break;                   
  3535.                 case IDC_BUTTON_VCR :
  3536.                     g_CurrentMode = VcrMode;
  3537.                     EndDialog(hwnd, TRUE);
  3538.                     break;
  3539.                 default :
  3540.                     break;
  3541.             } 
  3542.             break;            
  3543.         case WM_INITDIALOG:
  3544.             return TRUE;
  3545.     }
  3546.     return FALSE;
  3547. }
  3548.   
  3549. /*-------------------------------------------------------------------------
  3550. Routine:        DV_ChangeDecodeSizeProc
  3551. Purpose:        UI wrapper to change DV Decode size
  3552. Arguments:    Usual Dialog Processing parameters
  3553. Returns:        BOOL
  3554. Notes:          
  3555. ------------------------------------------------------------------------*/
  3556. BOOL CALLBACK DV_ChangeDecodeSizeProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  3557. {
  3558.     int iDisplayPix = 0;
  3559.     HRESULT hr;
  3560.  
  3561.     switch ( msg )
  3562.     {
  3563.         case WM_COMMAND:
  3564.             // Select which DV format resolution you would like to navigate to
  3565.             switch LOWORD(wParam)
  3566.             {
  3567.                 case IDOK :
  3568.                     //get selected size, and set size accordingly
  3569.                     if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_88x60)))
  3570.                     {
  3571.                         g_pDvDec->put_IPDisplay(DVRESOLUTION_DC);
  3572.                         g_iVWWidth = 88;    g_iVWHeight = 60;
  3573.                         g_iAppWidth = g_iVWWidth+5; g_iAppHeight = g_iVWHeight+135;
  3574.                         SendMessage(g_hwndApp, WM_SIZE, SIZE_RESTORED, MAKELONG(g_iAppWidth, g_iAppHeight));
  3575.                     } 
  3576.                     else if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_180x120)))
  3577.                     {
  3578.                         g_pDvDec->put_IPDisplay(DVRESOLUTION_QUARTER);
  3579.                         g_iVWWidth = 160;   g_iVWHeight = 120;
  3580.                         g_iAppWidth = g_iVWWidth+5; g_iAppHeight = g_iVWHeight+115;
  3581.                         SendMessage(g_hwndApp, WM_SIZE, SIZE_RESTORED, MAKELONG(g_iAppWidth, g_iAppHeight));
  3582.                     } 
  3583.                     else if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_360x240)))
  3584.                     {
  3585.                         g_pDvDec->put_IPDisplay(DVRESOLUTION_HALF);
  3586.                         g_iVWWidth = 360;   g_iVWHeight = 240;
  3587.                         g_iAppWidth = g_iVWWidth+5; g_iAppHeight = g_iVWHeight+95;
  3588.                         SendMessage(g_hwndApp, WM_SIZE, SIZE_RESTORED, MAKELONG(g_iAppWidth, g_iAppHeight));
  3589.                     } 
  3590.                     else if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_720x480)))
  3591.                     {
  3592.                         g_pDvDec->put_IPDisplay(DVRESOLUTION_FULL);
  3593.                         g_iVWWidth = 720;   g_iVWHeight = 480;
  3594.                         g_iAppWidth = g_iVWWidth+5; g_iAppHeight = g_iVWHeight+95;
  3595.                         SendMessage(g_hwndApp, WM_SIZE, SIZE_RESTORED, MAKELONG(g_iAppWidth, g_iAppHeight));
  3596.                     } 
  3597.                     else
  3598.                     {
  3599.                         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Invalid selection in DecodeSize Dialog"));
  3600.                     }                    
  3601.                 //safely fall through                    
  3602.  
  3603.                 case IDCANCEL :
  3604.                     //if it's the preview graph - restart it - otherwise leave it stopped
  3605.                     if (GRAPH_PREVIEW == g_iCurrentGraph)
  3606.                     {
  3607.                         DV_StartGraph();
  3608.                     } 
  3609.                     SAFE_RELEASE(g_pDvDec);
  3610.                     EndDialog(hwnd, TRUE);
  3611.                     break;
  3612.  
  3613.                 default :
  3614.                     break;
  3615.             } 
  3616.             break;
  3617.             
  3618.         case WM_INITDIALOG:
  3619.             /*
  3620.                 can't set the decode size if the graph is running - so we'll stop it.
  3621.                 there are other options, such as graying out the menu item whil the graph is 
  3622.                 playing that could be implemented.  For this simple application, this methos
  3623.                 will suffice.
  3624.             */
  3625.             if (SUCCEEDED(DV_StopGraph()))
  3626.             {
  3627.                 hr = g_pDVCodec->QueryInterface(IID_IIPDVDec, reinterpret_cast<PVOID *>(&g_pDvDec));
  3628.                 if (SUCCEEDED(hr))
  3629.                 {
  3630.                     hr = g_pDvDec->get_IPDisplay(&iDisplayPix);
  3631.                     //set button check appropriately
  3632.                     switch (iDisplayPix)
  3633.                     {
  3634.                         case DVRESOLUTION_DC :
  3635.                             Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_88x60), TRUE);
  3636.                             break;
  3637.  
  3638.                         case DVRESOLUTION_QUARTER :
  3639.                             Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_180x120), TRUE);
  3640.                             break;
  3641.  
  3642.                         case DVRESOLUTION_HALF :
  3643.                             Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_360x240), TRUE);
  3644.                             break;
  3645.  
  3646.                         case DVRESOLUTION_FULL :
  3647.                             Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_720x480), TRUE);
  3648.                             break;
  3649.  
  3650.                         default :
  3651.                             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Invalid return from get_IPDisplay"));
  3652.                             break;
  3653.                     } 
  3654.                 } 
  3655.                 else
  3656.                 {
  3657.                     MBOX(TEXT("Cannot determine current Decode size"));
  3658.                     EndDialog(hwnd, FALSE);
  3659.                     DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not get IIPDVDec interface.  hr = 0x%x"), hr);
  3660.                 } 
  3661.             } 
  3662.             else
  3663.             {
  3664.                 MBOX(TEXT("Could not stop graph"));
  3665.                 EndDialog(hwnd, FALSE);
  3666.             } 
  3667.             return TRUE;
  3668.     }
  3669.     return FALSE;
  3670. }
  3671.  
  3672. /*-------------------------------------------------------------------------
  3673. Routine:        DV_CapSizeDlgProc
  3674. Purpose:        Dialog proc for cap size dialog
  3675. Arguments:    Usual Dialog Processing parameters
  3676. Returns:        BOOL
  3677. Notes:          
  3678. ------------------------------------------------------------------------*/
  3679. BOOL CALLBACK DV_CapSizeDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  3680. {
  3681.   
  3682.     switch ( msg )
  3683.     {
  3684.         case WM_INITDIALOG:
  3685.         {
  3686.             TCHAR           capDisk[8];
  3687.             ULARGE_INTEGER  ulFreeBytes;
  3688.             ULARGE_INTEGER  ulTotalBytes;
  3689.             ULARGE_INTEGER  ulAvailBytes;
  3690.  
  3691.             // make sure output file name has been input for capture
  3692.             if (!g_OutputFileName[0])
  3693.             {
  3694.                 MBOX(TEXT("Please set up an output file name for recording"));
  3695.                 EndDialog(hwnd, FALSE);
  3696.                 return FALSE;
  3697.             } 
  3698.  
  3699.             //need to determine disk space and init the dialog appropriately
  3700.             lstrcpyn(capDisk, g_OutputFileName, 3);
  3701.             capDisk[4] = '\0';
  3702.             GetDiskFreeSpaceEx(capDisk, &ulFreeBytes, &ulTotalBytes, &ulAvailBytes);
  3703.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("Available MB on drive %s is %d MB"), capDisk, ulAvailBytes.QuadPart / (1024 * 1024));
  3704.  
  3705.             //let's see what our top limits are, and set our limits appropriately
  3706.             if ((ulAvailBytes.QuadPart / DV_BYTES_IN_MEG) < 120)
  3707.             {
  3708.                 //less than 120 MB available - subtract 10 MB at a time until we get a usable amount
  3709.                 UINT i = 110;
  3710.                 while ((ulAvailBytes.QuadPart / DV_BYTES_IN_MEG) < i)
  3711.                 {
  3712.                     i -= 10;
  3713.                 } 
  3714.                 SendMessage(GetDlgItem(hwnd, IDC_SPIN_TIME), UDM_SETRANGE, 0, MAKELONG(i / 4, 1));
  3715.                 SendMessage(GetDlgItem(hwnd, IDC_SPIN_SIZE), UDM_SETRANGE, 0, MAKELONG(i, 1));
  3716.             }
  3717.             else
  3718.             {
  3719.                 SendMessage(GetDlgItem(hwnd, IDC_SPIN_TIME), UDM_SETRANGE, 0, MAKELONG( ((ulAvailBytes.QuadPart / (1024 * 1024) ) - 10) / 4, 1));
  3720.                 SendMessage(GetDlgItem(hwnd, IDC_SPIN_SIZE), UDM_SETRANGE, 0, MAKELONG( (ulAvailBytes.QuadPart / (1024 * 1024) ) - 10, 1));
  3721.             }
  3722.  
  3723.             //enable / disable the controls as appropriate
  3724.             switch (g_dwCaptureLimit)
  3725.             {
  3726.                 case DV_CAPLIMIT_NONE :
  3727.                     Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_NOLIMIT), TRUE);
  3728.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_SIZE), FALSE);
  3729.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_SIZE), FALSE);
  3730.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_TIME), FALSE);
  3731.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_TIME), FALSE);
  3732.                     break;
  3733.                 
  3734.                 case DV_CAPLIMIT_TIME :
  3735.                 {
  3736.                     /*check the radio button, disable the size based controls */
  3737.                     Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_TIME), TRUE);
  3738.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_SIZE), FALSE);
  3739.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_SIZE), FALSE);
  3740.  
  3741.                     break;
  3742.                 }
  3743.                 case DV_CAPLIMIT_SIZE :
  3744.                 {
  3745.                     /*check the radio button, disable the time based controls */
  3746.                     Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_SIZE), TRUE);
  3747.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_TIME), FALSE);
  3748.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_TIME), FALSE);
  3749.                     
  3750.                     break;                    
  3751.                 }
  3752.             }
  3753.             SetDlgItemInt(hwnd, IDC_EDIT_TIME, g_dwTimeLimit, FALSE);
  3754.             SetDlgItemInt(hwnd, IDC_EDIT_SIZE, g_dwDiskSpace, FALSE);
  3755.             break;
  3756.         } 
  3757.         case WM_COMMAND :
  3758.             switch LOWORD(wParam)
  3759.             {
  3760.                 // Update the controls ui according to the choices made
  3761.                 case IDC_RADIO_NOLIMIT :
  3762.                 {
  3763.                     Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_NOLIMIT), TRUE);
  3764.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_SIZE), FALSE);
  3765.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_SIZE), FALSE);
  3766.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_TIME), FALSE);
  3767.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_TIME), FALSE);
  3768.                     break;
  3769.                 }
  3770.                     
  3771.                 case IDC_RADIO_TIME :
  3772.                 {
  3773.                     Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_TIME), TRUE);
  3774.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_SIZE), FALSE);
  3775.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_SIZE), FALSE);
  3776.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_TIME), TRUE);
  3777.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_TIME), TRUE);
  3778.                     break;
  3779.                 } 
  3780.                 
  3781.                 case IDC_RADIO_SIZE :
  3782.                 {
  3783.                     Button_SetCheck(GetDlgItem(hwnd, IDC_RADIO_SIZE), TRUE);
  3784.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_TIME), FALSE);
  3785.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_TIME), FALSE);
  3786.                     EnableWindow(GetDlgItem(hwnd, IDC_EDIT_SIZE), TRUE);
  3787.                     EnableWindow(GetDlgItem(hwnd, IDC_SPIN_SIZE), TRUE);
  3788.                     break;
  3789.                 } 
  3790.  
  3791.                 case IDOK :
  3792.                 {
  3793.                     BOOL bTranslated = FALSE;
  3794.                     // The selections are made
  3795.                     // update the new global capture flag
  3796.                     if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_NOLIMIT)))
  3797.                     {
  3798.                         g_dwCaptureLimit = DV_CAPLIMIT_NONE;
  3799.                         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("No capture size limit"));
  3800.                     } 
  3801.                     else if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_TIME)))   
  3802.                     {
  3803.                         g_dwTimeLimit = GetDlgItemInt(hwnd, IDC_EDIT_TIME, &bTranslated, FALSE);
  3804.                         g_dwCaptureLimit = DV_CAPLIMIT_TIME;
  3805.                         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Time based limit - %d"), g_dwTimeLimit);
  3806.                     } 
  3807.                     else if (Button_GetCheck(GetDlgItem(hwnd, IDC_RADIO_SIZE)))   
  3808.                     {
  3809.                         g_dwDiskSpace = GetDlgItemInt(hwnd, IDC_EDIT_SIZE, &bTranslated, FALSE);
  3810.                         g_dwCaptureLimit = DV_CAPLIMIT_SIZE;
  3811.                         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Disk based limit - %d MB"), g_dwDiskSpace);
  3812.                     } 
  3813.                     EndDialog(hwnd, TRUE);
  3814.                     return TRUE;
  3815.                 }
  3816.                 
  3817.                 case IDCANCEL :
  3818.                     // update nothing much
  3819.                     EndDialog(hwnd, FALSE);
  3820.                     return FALSE;
  3821.                 default :
  3822.                     return FALSE;
  3823.             }            
  3824.             return TRUE;
  3825.     }
  3826.     return FALSE;
  3827. }
  3828.  
  3829. /*-------------------------------------------------------------------------
  3830. Routine:        DV_GetTapeInfo
  3831. Purpose:        Get Frame rate and availability of dvcr tape
  3832. Arguments:    None
  3833. Returns:        HRESULT as appropriate
  3834. Notes:          
  3835. ------------------------------------------------------------------------*/
  3836. HRESULT DV_GetTapeInfo(void)
  3837. {
  3838.     HRESULT hr;
  3839.     LONG    lMediaType = 0;
  3840.     LONG    lInSignalMode = 0;
  3841.  
  3842.     // Query Media Type of the transport
  3843.     hr = g_pExtTrans->GetStatus(ED_MEDIA_TYPE, &lMediaType);
  3844.     if (SUCCEEDED(hr))
  3845.     {
  3846.         if (ED_MEDIA_NOT_PRESENT == lMediaType)
  3847.         {
  3848.             // Update the log & Status Window
  3849.             DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_SUCCINCT, TEXT("No tape is inserted"));
  3850.             DV_StatusText(TEXT("VCR Mode - No tape, or unknown format"), 2);
  3851.             //we want to return failure if there is no tape installed
  3852.             hr = S_FALSE;  
  3853.         } 
  3854.         else
  3855.         {
  3856.             //tape type should always be DVC
  3857.             ASSERT(ED_MEDIA_DVC == lMediaType);
  3858.  
  3859.             // Now lets query for the signal mode of the tape.
  3860.             g_pExtTrans->GetTransportBasicParameters(ED_TRANSBASIC_INPUT_SIGNAL, &lInSignalMode, NULL);
  3861.             Sleep(_MAX_SLEEP);
  3862.             if (SUCCEEDED(hr))
  3863.             {   // determine whether the camcorder supports ntsc or pal
  3864.                 switch (lInSignalMode)
  3865.                 {
  3866.                     case ED_TRANSBASIC_SIGNAL_525_60_SD :
  3867.                     g_AvgTimePerFrame = 33;  // 33 milli-sec (29.97 FPS)
  3868.                     DV_StatusText(TEXT("VCR Mode - NTSC"), 2);
  3869.                     break;
  3870.  
  3871.                 case ED_TRANSBASIC_SIGNAL_525_60_SDL :
  3872.                     g_AvgTimePerFrame = 33;  // 33 milli-sec (29.97 FPS)
  3873.                     DV_StatusText(TEXT("VCR Mode - NTSC"), 2);
  3874.                     break;
  3875.  
  3876.                 case ED_TRANSBASIC_SIGNAL_625_50_SD :
  3877.                     g_AvgTimePerFrame = 40;  // 40 milli-sec (25FPS)
  3878.                     DV_StatusText(TEXT("VCR Mode - PAL"), 2);
  3879.                     break;
  3880.  
  3881.                 case ED_TRANSBASIC_SIGNAL_625_50_SDL :
  3882.                     g_AvgTimePerFrame = 40;  // 40 milli-sec (25FPS)
  3883.                     DV_StatusText(TEXT("VCR Mode - PAL"), 2);
  3884.                     break;
  3885.  
  3886.                 default : 
  3887.                     DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Unsupported or unrecognized tape format type"));
  3888.                     g_AvgTimePerFrame = 33;  // 33 milli-sec (29.97 FPS); default
  3889.                     break;
  3890.                 }
  3891.  
  3892.                 DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Avg time per frame is %d FPS"), g_AvgTimePerFrame);
  3893.             } 
  3894.             else
  3895.             {
  3896.                 DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("GetTransportBasicParameters Failed (0x%x)"), hr);
  3897.             } 
  3898.         }
  3899.     }
  3900.     else
  3901.     {
  3902.         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("GetStatus Failed (0x%x)"), hr);
  3903.     } 
  3904.     return hr;
  3905. }
  3906.  
  3907. /*-------------------------------------------------------------------------
  3908. Routine:        DV_RefreshMode
  3909. Purpose:        Use this to rebuild the necessary stuff to switch between VCR and camera mode
  3910. Arguments:    None
  3911. Returns:        TRUE if successful
  3912. Notes:          
  3913. ------------------------------------------------------------------------*/
  3914. BOOL DV_RefreshMode(void)
  3915. {
  3916.     BOOL bStatus    = FALSE;
  3917.     // Query the current device type    
  3918.     switch(DV_GetDVMode())
  3919.     {
  3920.         case CameraMode :
  3921.             // update the Graph Mode menu items & status window
  3922.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV, MF_GRAYED);
  3923.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV_NOPRE, MF_GRAYED);
  3924.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV_TYPE2, MF_GRAYED);
  3925.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV_NOPRE_TYPE2, MF_GRAYED);
  3926.             EnableMenuItem(GetMenu(g_hwndApp), IDM_CHECKTAPE, MF_GRAYED);
  3927.             DV_StatusText(TEXT("Camera Mode"), 2);
  3928.             bStatus = TRUE;
  3929.             break;
  3930.  
  3931.         case VcrMode :
  3932.             // Query the tape info & update the status bar
  3933.             DV_GetTapeInfo();  
  3934.             // update the Graph Mode menu items & status window
  3935.             EnableMenuItem(GetMenu(g_hwndApp), IDM_CHECKTAPE, MF_ENABLED);
  3936.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV, MF_ENABLED);
  3937.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV_NOPRE, MF_ENABLED);
  3938.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV_TYPE2, MF_ENABLED);
  3939.             EnableMenuItem(GetMenu(g_hwndApp), IDM_FILETODV_NOPRE_TYPE2, MF_ENABLED);
  3940.             EnableMenuItem(GetMenu(g_hwndApp), IDM_CHECKTAPE, MF_ENABLED);
  3941.             bStatus = TRUE;
  3942.             break;
  3943.  
  3944.         case UnknownMode :
  3945.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Should not have reached unknown mode handler"));
  3946.             break;
  3947.             
  3948.         default :
  3949.             DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Could not determine Camera/Vcr Mode"));
  3950.             break;
  3951.     }
  3952.     return bStatus;
  3953. } 
  3954.  
  3955. /*-------------------------------------------------------------------------
  3956. Routine:        DV_WriteRegKeys
  3957. Purpose:        Save the input and output file names to the registry
  3958. Arguments:    None
  3959. Returns:        None
  3960. Notes:          
  3961. ------------------------------------------------------------------------*/
  3962. void DV_WriteRegKeys(void)
  3963. {
  3964.     HKEY hKey;
  3965.     LONG lResult;
  3966.     DWORD dwDisp = 0;
  3967.     // Create DVApp's registry keys
  3968.     lResult = RegCreateKeyEx(HKEY_CURRENT_USER, 
  3969.                              TEXT("Software\\Microsoft\\DVApp"), 
  3970.                              NULL, 
  3971.                              NULL, 
  3972.                              REG_OPTION_NON_VOLATILE, 
  3973.                              KEY_ALL_ACCESS, 
  3974.                              NULL,
  3975.                              &hKey,
  3976.                              &dwDisp);
  3977.  
  3978.     // Write the input & output filenames
  3979.     if (REG_OPENED_EXISTING_KEY == dwDisp ||  REG_CREATED_NEW_KEY == dwDisp) 
  3980.     {
  3981.         //note that the sizeof parameter expects BYTES (not characters)
  3982.         RegSetValueEx(hKey, TEXT("InputFile"), NULL, REG_SZ, (PBYTE)g_InputFileName, (lstrlen(g_InputFileName) * sizeof(TCHAR)) + sizeof(TCHAR));
  3983.         RegSetValueEx(hKey, TEXT("OutputFile"), NULL, REG_SZ, (PBYTE)g_OutputFileName, (lstrlen(g_OutputFileName) * sizeof(TCHAR)) + sizeof(TCHAR));
  3984.         RegCloseKey(hKey);
  3985.     }
  3986. } 
  3987.  
  3988.  
  3989. /*-------------------------------------------------------------------------
  3990. Routine:        DV_ReadRegKeys
  3991. Purpose:        Save the input and output file names to the registry
  3992. Arguments:    None
  3993. Returns:        None
  3994. Notes:          
  3995. ------------------------------------------------------------------------*/
  3996. void DV_ReadRegKeys(void)
  3997. {
  3998.     HKEY hKey;
  3999.     LONG lResult;
  4000.     DWORD dwType;
  4001.     DWORD a = MAX_PATH * sizeof(TCHAR), b = MAX_PATH * sizeof(TCHAR);
  4002.     // Read the DVApp's registry keys
  4003.     lResult = RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\DVApp"), NULL, KEY_ALL_ACCESS, &hKey);
  4004.  
  4005.     // Load the input & output filenames
  4006.     if (ERROR_SUCCESS == lResult)
  4007.     {
  4008.         RegQueryValueEx(hKey, TEXT("InputFile"), NULL, &dwType, (PBYTE)g_InputFileName, &a);
  4009.         RegQueryValueEx(hKey, TEXT("OutputFile"), NULL, &dwType, (PBYTE)g_OutputFileName, &b);
  4010.         RegCloseKey(hKey);
  4011.     }
  4012.     
  4013. }
  4014.  
  4015.  
  4016. /*-------------------------------------------------------------------------
  4017. Routine:        DV_SaveGraph
  4018. Purpose:        Save the filter graph into a *.grf file
  4019. Arguments:    FileName
  4020. Returns:        HRESULT as appropriate
  4021. Notes:          
  4022. ------------------------------------------------------------------------*/
  4023. HRESULT DV_SaveGraph(TCHAR* sGraphFile)
  4024. {
  4025.     IStorage *          pStorage = NULL;
  4026.     IStream *           pStream = NULL;
  4027.     IPersistStream *    pPersistStream = NULL;
  4028.     HRESULT             hr = S_OK;
  4029.  
  4030.     if(g_pGraphBuilder == NULL || sGraphFile == NULL)
  4031.         return E_FAIL;
  4032.  
  4033. #ifndef UNICODE
  4034.     WCHAR swGraphFile[MAX_PATH];
  4035.     MultiByteToWideChar(CP_ACP, 0, sGraphFile, -1, swGraphFile, MAX_PATH);
  4036.  
  4037.     // Either Open or Create the *.GRF file
  4038.     hr = StgOpenStorage( swGraphFile, NULL, STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_DENY_WRITE, NULL, NULL, &pStorage );
  4039.     if ( STG_E_FILENOTFOUND == hr )
  4040.         hr = StgCreateDocfile( swGraphFile, STGM_CREATE | STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE , NULL , &pStorage);
  4041. #else
  4042.     // Either Open or Create the *.GRF file
  4043.     hr = StgOpenStorage( sGraphFile, NULL, STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_DENY_WRITE, NULL, NULL, &pStorage );
  4044.     if ( STG_E_FILENOTFOUND == hr )
  4045.         hr = StgCreateDocfile( sGraphFile, STGM_CREATE | STGM_TRANSACTED | STGM_2READWRITE | STGM_SHARE_EXCLUSIVE , NULL , &pStorage);
  4046.  
  4047. #endif
  4048.  
  4049.     if ( SUCCEEDED(hr) )
  4050.         hr = pStorage->CreateStream( L"ActiveMovieGraph", STGM_WRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, NULL, NULL, &pStream );
  4051.  
  4052.     // Persist the stream, save & commit to disk
  4053.     if ( SUCCEEDED(hr) )
  4054.         hr = g_pGraphBuilder->QueryInterface( IID_IPersistStream, (void **) &pPersistStream );
  4055.     if ( SUCCEEDED(hr) )
  4056.         hr = pPersistStream->Save(pStream, TRUE);
  4057.     if ( SUCCEEDED(hr) )
  4058.         hr = pStorage->Commit( STGC_DEFAULT );
  4059.  
  4060.     if ( SUCCEEDED(hr) )
  4061.         DV_LogOut(LOG_PRIORITY_INFO, LOG_LEVEL_MEDIUM, TEXT("Save current Filter Graph to GRF file succeded"));
  4062.     else
  4063.     {
  4064.         MessageBox( NULL, "Save GRF file failed", "DVApp", MB_ICONEXCLAMATION | MB_OK );
  4065.         DV_LogOut(LOG_PRIORITY_ERROR, LOG_LEVEL_SUCCINCT, TEXT("Save current Filter Graph to GRF file failed"));
  4066.     }
  4067.     SAFE_RELEASE(pStorage);
  4068.     SAFE_RELEASE(pStream);
  4069.     SAFE_RELEASE(pPersistStream);
  4070.  
  4071.     return hr;
  4072. }
  4073.  
  4074. /*-------------------------------------------------------------------------
  4075. Routine:        DV_LogOut 
  4076. Purpose:        Show the Message Window with the Log string 
  4077. Arguments:    logging priority, logging level & the message
  4078. Returns:        None
  4079. Notes:          Logs according to the current logging priority & level set
  4080. ------------------------------------------------------------------------*/
  4081. void __cdecl DV_LogOut (LOG_PRIORITY iPriority, LOG_LEVEL ilevel, TCHAR *szFormat, ... )
  4082. {
  4083.     static TCHAR msg[1024];
  4084.     va_list va;
  4085.     va_start(va, szFormat);
  4086.     wvsprintf (msg, szFormat, va);
  4087.     va_end(va);
  4088.  
  4089.     if ( ilevel > g_iLogLevel )         // we can skip this message
  4090.         return;
  4091.     if ( iPriority > g_iLogPriority )   // we can skip this message
  4092.         return;
  4093.  
  4094.     MBOX(msg);
  4095.     return;
  4096. } 
  4097.  
  4098.