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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
VIDCAP.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：70k
源码类别：

Windows编程

开发平台：

Visual C++

VIDCAP.C：源码内容
  1. /**************************************************************************
  2.  *
  3.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6.  *  PURPOSE.
  7.  *
  8.  *  Copyright (C) 1992 - 1997 Microsoft Corporation.  All Rights Reserved.
  9.  *
  10.  **************************************************************************/
  11. /****************************************************************************
  12.  *
  13.  *   vidcap.c: WinMain and command processing
  14.  *
  15.  *   Vidcap32 Source code
  16.  *
  17.  ***************************************************************************/
  18.  
  19. #include <windows.h>
  20. #include <windowsx.h>
  21. #include <commdlg.h>
  22. #include <mmsystem.h>
  23. #include <mmreg.h>
  24. #include <io.h>
  25. #include <fcntl.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <memory.h>
  29. #include <dos.h>
  30. #include <shellapi.h>
  31. #include <vfw.h>
  33. #include "vidcap.h"
  34. #include "vidframe.h"
  35. #include "profile.h"
  37. // generic window control classes
  38. #include "toolbar.h"
  39. #include "status.h"
  40. #include "arrow.h"
  41. #include "rlmeter.h"
  42. #include "help.h"
  44. // the standard toolbar class 'exports' this but doesn't put it in the
  45. // header file
  46. extern char     szToolBarClass[];//HACK!
  49. // height of the buttons on a toolbar - depends on the
  50. // size of the bitmaps within IDBMP_TOOLBAR
  51. #define BUTTONWIDTH     24
  52. #define BUTTONHEIGHT    22
  53. #define TOOLBAR_HEIGHT          BUTTONHEIGHT + 6
  56. // description and layout of toolbar buttons within IDBMP_TOOLBAR
  57. #define APP_NUMTOOLS 8
  59. #define BTN_SETFILE 0
  60. #define BTN_EDITCAP 1
  61. #define BTN_LIVE 2
  62. #define BTN_CAPFRAME 3
  63. #define BTN_CAPSEL 4
  64. #define BTN_CAPAVI 5
  65. #define BTN_CAPPAL 6
  66. #define BTN_OVERLAY 7
  68. static int           aiButton[] = {BTN_SETFILE, BTN_EDITCAP,
  69.                             BTN_LIVE, BTN_OVERLAY, BTN_CAPFRAME,
  70.                             BTN_CAPSEL, BTN_CAPAVI, BTN_CAPPAL };
  71. static int           aiState[] = {BTNST_FOCUSUP, BTNST_UP,
  72.                             BTNST_UP, BTNST_UP, BTNST_UP,
  73.                             BTNST_UP, BTNST_UP, BTNST_UP};
  74. static int           aiType[] ={BTNTYPE_PUSH, BTNTYPE_PUSH,
  75.                             BTNTYPE_CHECKBOX, BTNTYPE_CHECKBOX,
  76.                             BTNTYPE_PUSH,
  77.                             BTNTYPE_PUSH, BTNTYPE_PUSH, BTNTYPE_PUSH};
  78. static int           aiString[] = { IDC_toolbarSETFILE,
  79.                             IDC_toolbarEDITCAP, IDC_toolbarLIVE,
  80.                             IDC_toolbarOVERLAY,
  81.                             IDC_toolbarCAPFRAME, IDC_toolbarCAPSEL,
  82.                             IDC_toolbarCAPAVI, IDC_toolbarCAPPAL };
  83. static int           aPos[] = { 10, 35, 75, 100, 150, 175, 200, 225 };
  88. //
  89. // Global Variables
  90. //
  92. // preferences
  93. BOOL gbCentre;
  94. BOOL gbToolBar;
  95. BOOL gbStatusBar;
  96. BOOL gbAutoSizeFrame;
  97. int gBackColour;
  99. BOOL gbLive, gbOverlay;
  100. BOOL gfIsRTL;
  102. // saved window sizes
  103. int gWinX, gWinY;
  104. int gWinCX, gWinCY;
  105. int gWinShow;
  107. // command line options
  108. int gCmdLineDeviceID = -1;
  111. char           gachAppName[]  = "vidcapApp" ;
  112. char           gachIconName[] = "vidcapIcon" ;
  113. char           gachMenuName[] = "vidcapMenu" ;
  114. char           gachAppTitle[20];    //VidCap
  115. char           gachCaptureFile[_MAX_PATH];
  116. char           gachMCIDeviceName[21];
  117. char           gachString[128] ;
  118. char           gachBuffer[200] ;
  119. char           gachLastError[256];
  122. HINSTANCE      ghInstApp ;
  123. HWND           ghWndMain = NULL ;
  124. HWND           ghWndFrame;      // child of ghWndMain  - frames and scrolls
  125. HWND           ghWndCap  ;      // child of ghWndCap
  126. HWND           ghWndToolBar;
  127. HWND           ghWndStatus;
  129. HANDLE         ghAccel ;
  130. WORD           gwDeviceIndex ;
  131. WORD           gwPalFrames = DEF_PALNUMFRAMES ;
  132. WORD           gwPalColors = DEF_PALNUMCOLORS ;
  133. WORD           gwCapFileSize ;
  135. CAPSTATUS      gCapStatus ;
  136. CAPDRIVERCAPS  gCapDriverCaps ;
  137. CAPTUREPARMS   gCapParms ;
  138. BOOL           gbHaveHardware;
  139. UINT           gDriverCount;
  140. BOOL           gbIsScrncap;  // For Scrncap.drv, we must yield
  141. BOOL           gbInLayout;
  142. UINT           gAVStreamMaster;
  144. HANDLE         ghwfex ;
  145. LPWAVEFORMATEX glpwfex ;
  147. FARPROC        fpErrorCallback ;
  148. FARPROC        fpStatusCallback ;
  149. FARPROC        fpYieldCallback ;
  152. // set to false when we capture a palette (or if we have warned him and
  153. // he says its ok
  154. BOOL bDefaultPalette = TRUE;
  156. #ifdef DEBUG
  157. int nTestCount;
  158. #endif
  160. // c-runtime cmd line
  161. extern char ** __argv;
  162. extern int __argc;
  164. #define LimitRange(Val,Low,Hi) (max(Low,(min(Val,Hi))))
  167. //
  168. // Function prototypes
  169. //
  170. LONG FAR PASCAL MainWndProc(HWND, UINT, UINT, LONG) ;
  171. LRESULT FAR PASCAL ErrorCallbackProc(HWND, int, LPSTR) ;
  172. LRESULT FAR PASCAL StatusCallbackProc(HWND, int, LPSTR) ;
  173. LRESULT FAR PASCAL YieldCallbackProc(HWND) ;
  174. void vidcapSetLive(BOOL bLive);
  175. void vidcapSetOverlay(BOOL bOverlay);
  176. void vidcapSetCaptureFile(LPSTR pFileName);
  178. BOOL vidcapRegisterClasses(HINSTANCE hInstance, HINSTANCE hPrevInstance);
  179. BOOL vidcapCreateWindows(HINSTANCE hInstance, HINSTANCE hPrevInstance);
  180. void vidcapLayout(HWND hwnd);
  181. BOOL vidcapEnumerateDrivers(HWND hwnd);
  182. BOOL vidcapInitHardware(HWND hwnd, HWND hwndCap, UINT uIndex);
  183. void vidcapReadProfile(void);
  184. void vidcapWriteProfile(void);
  185. void vidcapReadSettingsProfile(void);
  186. void vidcapWriteSettingsProfile(void);
  189. /* --- initialisation -------------------------------------------------- */
  192. //
  193. // WinMain: Application Entry Point Function
  194. //
  195. int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
  196. {
  197. ///////////////////////////////////////////////////////////////////////
  198. //  hInstance:      handle for this instance
  199. //  hPrevInstance:  handle for possible previous instances
  200. //  lpszCmdLine:    long pointer to exec command line
  201. //  nCmdShow:       Show code for main window display
  202. ///////////////////////////////////////////////////////////////////////
  204.     MSG          msg ;
  205.     BOOL bValidCmdline;
  206.     BOOL fOK;
  207.     int i;
  208.     char ach[2];
  210.     ghInstApp = hInstance ;
  211.     LoadString(hInstance, IDS_CAP_RTL, ach, sizeof(ach));
  212.     gfIsRTL = ach[0] == '1';
  213.     gCmdLineDeviceID = -1;
  215.     // read the app title string - used in several message boxes
  216.     LoadString(hInstance, IDS_APP_TITLE, gachAppTitle, sizeof(gachAppTitle));
  218.     // read defaults out of the registry
  219.     vidcapReadProfile();
  221.     // look for cmd line options
  222.     bValidCmdline = TRUE;
  224.     for ( i = 1; (i < __argc) && bValidCmdline; i++) {
  225.         if ((__argv[i][0] == '/') || (__argv[i][0] == '-')) {
  227.             switch(__argv[i][1]) {
  228.             case 'D':
  229.             case 'd':
  230.                 if (gCmdLineDeviceID < 0) {
  231.                     // allow "-d0" and "-d 0"
  232.                     PSTR p = &__argv[i][2];
  234.                     if ((*p == 0) && ((i+1) < __argc)) {
  235.                         p = __argv[++i];
  236.                     }
  239.                     gCmdLineDeviceID = atoi(p);
  240.                 } else {
  241.                     bValidCmdline = FALSE;
  242.                 }
  243.                 break;
  245.             default:
  246.                 bValidCmdline = FALSE;
  247.             }
  248.         } else {
  249.             bValidCmdline = FALSE;
  250.         }
  251.     }
  252.     
  253.     if (gCmdLineDeviceID == -1)
  254. gCmdLineDeviceID = 0;
  257.     if (!bValidCmdline) {
  258.         MessageBoxID(IDS_ERR_CMDLINE, MB_OK|MB_ICONEXCLAMATION);
  259.         return(0);
  260.     }
  262.     if (!vidcapRegisterClasses(hInstance, hPrevInstance)) {
  264.         MessageBoxID(IDS_ERR_REGISTER_CLASS,
  265.         MB_ICONEXCLAMATION) ;
  266.         return 0 ;
  267.     }
  270.     if (!vidcapCreateWindows(hInstance, hPrevInstance)) {
  272.         MessageBoxID(IDS_ERR_CREATE_WINDOW,
  273.         MB_ICONEXCLAMATION | MB_OK) ;
  274.         return IDS_ERR_CREATE_WINDOW ;
  275.     }
  277.     // Get the default setup for video capture from the AVICap window
  278.     capCaptureGetSetup(ghWndCap, &gCapParms, sizeof(CAPTUREPARMS)) ;
  280.     // Overwrite the defaults with settings we have saved in the profile
  281.     vidcapReadSettingsProfile();
  283.     // Show the main window before connecting the hardware as this can be
  284.     // time consuming and the user should see something happening first...
  285.     ShowWindow(ghWndMain, nCmdShow) ;
  286.     UpdateWindow(ghWndMain) ;
  287.     ghAccel = LoadAccelerators(hInstance, "VIDCAP") ;
  289.     // Create a list of all capture drivers and append them to the Options menu
  290.     if (!(fOK = vidcapEnumerateDrivers(ghWndMain))) {
  291. LoadString(ghInstApp, IDS_ERR_FIND_HARDWARE, gachLastError, sizeof(gachLastError));
  292.     }
  293.     // Try to connect to a capture driver
  294.     else if (fOK = vidcapInitHardware(ghWndMain, ghWndCap, 
  295.        bValidCmdline ? gCmdLineDeviceID : 0)) {
  296. // Hooray, we now have a capture driver connected!
  297.         vidcapSetCaptureFile(gachCaptureFile);
  298.     }
  299.     
  300.     if (!fOK) {
  301.         if (!DoDialog(ghWndMain, IDD_NoCapHardware, NoHardwareDlgProc,
  302.                         (LONG) (LPSTR) gachLastError)) {
  303.             // The user has asked to abort, since no driver was available
  304.             PostMessage(ghWndMain, WM_COMMAND,
  305.                         GET_WM_COMMAND_MPS(IDM_F_EXIT, 0, 0));
  306.         }
  307.     }
  308.     
  309.     // All set; get and process messages
  310.     while (GetMessage(&msg, NULL, 0, 0)) {
  311.         if (! TranslateAccelerator(ghWndMain, ghAccel, &msg)) {
  312.             TranslateMessage(&msg) ;
  313.             DispatchMessage(&msg) ;
  314.         }
  315.     }
  317.     return msg.wParam;
  318. }  // End of WinMain
  321. BOOL
  322. vidcapRegisterClasses(HINSTANCE hInstance, HINSTANCE hPrevInstance)
  323. {
  324.     WNDCLASS wc;
  326.     if (! hPrevInstance) {
  327.         // If it's the first instance, register the window class
  328.         wc.lpszClassName = gachAppName ;
  329.         wc.hInstance     = hInstance ;
  330.         wc.lpfnWndProc   = MainWndProc ;
  331.         wc.hCursor       = LoadCursor(NULL, IDC_ARROW) ;
  332.         wc.hIcon         = LoadIcon(hInstance, gachIconName) ;
  333.         wc.lpszMenuName  = gachMenuName ;
  334.         wc.hbrBackground = GetStockObject(WHITE_BRUSH) ;
  335.         wc.style         = CS_HREDRAW | CS_VREDRAW ;
  336.         wc.cbClsExtra    = 0 ;
  337.         wc.cbWndExtra    = 0 ;
  339.         if (!RegisterClass(&wc)) {
  340.             return(FALSE);
  341.         }
  343.         if (!ArrowInit(hInstance)) {
  344.             return(FALSE);
  345.         }
  347.         if (!RLMeter_Register(hInstance)) {
  348.             return(FALSE);
  349.         }
  350.     }
  352.     if (!toolbarInit(hInstance, hPrevInstance)) {
  353.         return(FALSE);
  354.     }
  356.     if (!statusInit(hInstance, hPrevInstance)) {
  357.         return(FALSE);
  358.     }
  359.     return(TRUE);
  361. }
  363. BOOL
  364. vidcapCreateWindows(HINSTANCE hInstance, HINSTANCE hPrevInstance)
  365. {
  367.     POINT pt;
  368.     RECT rc;
  369.     TOOLBUTTON tb;
  370.     int i;
  372.     // Create Application's Main window
  373.     ghWndMain = CreateWindowEx(
  374.             gfIsRTL ? WS_EX_LEFTSCROLLBAR | WS_EX_RIGHT | WS_EX_RTLREADING : 0,
  375.             gachAppName,
  376.             gachAppTitle,
  377.             WS_CAPTION      |
  378.             WS_SYSMENU      |
  379.             WS_MINIMIZEBOX  |
  380.             WS_MAXIMIZEBOX  |
  381.             WS_THICKFRAME   |
  382.             WS_CLIPCHILDREN |
  383.             WS_OVERLAPPED,
  384.             gWinX, gWinY,
  385.             gWinCX, gWinCY,
  386.             NULL,
  387.             NULL,
  388.             hInstance,
  389.             0) ;
  391.     if (ghWndMain == NULL) {
  392.         return(FALSE);
  393.     }
  396.     /*
  397.      * create a vidframe child window - this will create a child
  398.      * AVICAP window within itself.
  399.      *
  400.      * Don't worry about size and position - vidcapLayout will do this
  401.      * later (once we know the video format size).
  402.      */
  403.     ghWndFrame = vidframeCreate(
  404.                     ghWndMain,
  405.                     hInstance,
  406.                     hPrevInstance,
  407.                     0, 0, 0, 0,
  408.                     &ghWndCap);
  410.     if ((ghWndFrame == NULL) || (ghWndCap == NULL)) {
  411.         return(FALSE);
  412.     }
  414.     // Register the status and error callbacks before driver connects
  415.     // so we can get feedback about the connection process
  416.     fpErrorCallback = MakeProcInstance((FARPROC)ErrorCallbackProc, ghInstApp) ;
  417.     capSetCallbackOnError(ghWndCap, fpErrorCallback) ;
  419.     fpStatusCallback = MakeProcInstance((FARPROC)StatusCallbackProc, ghInstApp) ;
  420.     capSetCallbackOnStatus(ghWndCap, fpStatusCallback) ;
  422.     // We'll only install a yield callback later if using Scrncap.drv
  423.     fpYieldCallback = MakeProcInstance((FARPROC)YieldCallbackProc, ghInstApp) ;
  424.     
  426.     /*
  427.      * CREATE THE TOOL BAR WINDOW
  428.      */
  429.     /* NOTE: let vidcapLayout() position it */
  430.     ghWndToolBar = CreateWindowEx(
  431.             gfIsRTL ? WS_EX_LEFTSCROLLBAR | WS_EX_RIGHT | WS_EX_RTLREADING : 0,
  432.             szToolBarClass,
  433.             NULL,
  434.             WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP|
  435.             WS_CLIPSIBLINGS,
  436.             0, 0,
  437.             0, 0,
  438.             ghWndMain,
  439.             NULL,
  440.             hInstance,
  441.             NULL);
  444.     if (ghWndToolBar == NULL) {
  445.         return(FALSE);
  446.     }
  448.     /* set the bitmap and button size to be used for this toolbar */
  449.     pt.x = BUTTONWIDTH;
  450.     pt.y = BUTTONHEIGHT;
  451.     toolbarSetBitmap(ghWndToolBar, hInstance, IDBMP_TOOLBAR, pt);
  453.     for (i = 0; i < APP_NUMTOOLS; i++) {
  454. rc.left = aPos[i];
  455. rc.top = 2;
  456. rc.right = rc.left + pt.x;
  457. rc.bottom = rc.top + pt.y;
  458. tb.rc = rc;
  459. tb.iButton = aiButton[i];
  460. tb.iState = aiState[i];
  461. tb.iType = aiType[i];
  462. tb.iString = aiString[i];
  463. toolbarAddTool(ghWndToolBar, tb);
  464.     }
  466.     // create the status bar - let vidcapLayout do the positioning
  467.     ghWndStatus = CreateWindowEx(
  468.                     gfIsRTL ? WS_EX_LEFTSCROLLBAR | WS_EX_RIGHT | WS_EX_RTLREADING : 0,
  469.                     szStatusClass,
  470.                     NULL,
  471.                     WS_CHILD|WS_BORDER|WS_VISIBLE|WS_CLIPSIBLINGS,
  472.                     0, 0,
  473.                     0, 0,
  474.                     ghWndMain,
  475.                     NULL,
  476.                     hInstance,
  477.                     NULL);
  478.     if (ghWndStatus == NULL) {
  479.         return(FALSE);
  480.     }
  482.     return(TRUE);
  484. }
  486. /*
  487.  * Enumerate the potential capture drivers and add the list to the Options
  488.  * menu.  This function is only called once at startup.
  489.  * Returns FALSE if no drivers are available.
  490.  */
  491. BOOL
  492. vidcapEnumerateDrivers(HWND hwnd)
  493. {
  494.     char    achDeviceVersion[80] ;
  495.     char    achDeviceAndVersion[160] ;
  496.     UINT    uIndex ;
  497.     HMENU   hMenuSub;
  499.     gDriverCount = 0 ;
  501.     hMenuSub = GetSubMenu (GetMenu (hwnd), 2);  // Options menu
  503.     for (uIndex = 0 ; uIndex < MAXVIDDRIVERS ; uIndex++) {
  504.         if (capGetDriverDescription(uIndex,
  505.                        (LPSTR)achDeviceAndVersion, sizeof(achDeviceAndVersion),
  506.                        (LPSTR)achDeviceVersion, sizeof(achDeviceVersion))) {
  507.             // Concatenate the device name and version strings
  508.             lstrcat (achDeviceAndVersion, ",   ");
  509.             lstrcat (achDeviceAndVersion, achDeviceVersion);
  511.             AppendMenu (hMenuSub, 
  512.                         MF_STRING,
  513.                         IDM_O_DRIVER0 + uIndex, 
  514.                         achDeviceAndVersion);
  515.             gDriverCount++;
  516.         }
  517.         else
  518.             break;
  519.     }  
  521.     // Now refresh menu, position capture window, start driver etc
  522.     DrawMenuBar(ghWndMain) ;
  524.     return (gDriverCount);
  525. }
  527. /*
  528.  * Connect the capture window to a capture driver.
  529.  * uIndex specifies the index of the driver to use.
  530.  * Returns TRUE on success, or FALSE if the driver connection failed.
  531.  */
  532. BOOL
  533. vidcapInitHardware(HWND hwnd, HWND hwndCap, UINT uIndex)
  534. {
  535.     UINT    uError ;
  536.     UINT    uI;
  537.     HMENU   hMenu;
  538.     char    szName[MAX_PATH];
  539.     char    szVersion[MAX_PATH];
  541.     // Since the driver may not provide a reliable error string
  542.     // provide a default
  543.     LoadString(ghInstApp, IDS_ERR_FIND_HARDWARE, gachLastError, sizeof(gachLastError));
  545.     // Try connecting to the capture driver
  546.     if (uError = capDriverConnect(hwndCap, uIndex)) {
  547.         gbHaveHardware = TRUE;
  548.         gwDeviceIndex = uIndex;
  549.     }
  550.     else {
  551.         gbHaveHardware = FALSE;
  552.         gbLive = FALSE;
  553.         gbOverlay = FALSE;
  554.     }
  556.     // Get the capabilities of the capture driver
  557.     capDriverGetCaps(hwndCap, &gCapDriverCaps, sizeof(CAPDRIVERCAPS)) ;
  559.     // Get the settings for the capture window
  560.     capGetStatus(hwndCap, &gCapStatus , sizeof(gCapStatus));
  562.     // Modify the toolbar buttons
  563.     toolbarModifyState(ghWndToolBar, BTN_CAPFRAME, 
  564.         gbHaveHardware ? BTNST_UP : BTNST_GRAYED);
  565.     toolbarModifyState(ghWndToolBar, BTN_CAPSEL, 
  566.         gbHaveHardware ? BTNST_UP : BTNST_GRAYED);
  567.     toolbarModifyState(ghWndToolBar, BTN_CAPAVI, 
  568.         gbHaveHardware ? BTNST_UP : BTNST_GRAYED);
  569.     toolbarModifyState(ghWndToolBar, BTN_LIVE, 
  570.         gbHaveHardware ? BTNST_UP : BTNST_GRAYED);
  572.     // Is overlay supported?
  573.     toolbarModifyState(ghWndToolBar, BTN_OVERLAY, 
  574.         (gbHaveHardware && gCapDriverCaps.fHasOverlay) ? 
  575.         BTNST_UP : BTNST_GRAYED);
  577.     // Can the device create palettes?
  578.     toolbarModifyState(ghWndToolBar, BTN_CAPPAL, 
  579.         (gbHaveHardware && gCapDriverCaps.fDriverSuppliesPalettes) ? 
  580.         BTNST_UP : BTNST_GRAYED);
  582.     // Check the appropriate driver in the Options menu
  583.     hMenu = GetMenu (hwnd);
  584.     for (uI = 0; uI < gDriverCount; uI++) {
  585.         CheckMenuItem (hMenu, IDM_O_DRIVER0 + uI, 
  586.                 MF_BYCOMMAND | ((uIndex == uI) ? MF_CHECKED : MF_UNCHECKED));
  587.     } 
  589.     // Unlike all other capture drivers, Scrncap.drv needs to use
  590.     // a Yield callback, and we don't want to abort on mouse clicks,
  591.     // so determine if the current driver is Scrncap.drv
  592.     capGetDriverDescription (uIndex, 
  593.                 szName, sizeof (szName),
  594.                 szVersion, sizeof (szVersion));
  596.     // Set a flag if we're using Scrncap.drv
  597.     gbIsScrncap = (BOOL) _fstrstr (szName, "Screen Capture");
  599.     // Get video format and adjust capture window
  600.     vidcapLayout(ghWndMain);
  601.     InvalidateRect(ghWndMain, NULL, TRUE);
  603.     // set the preview rate (units are millisecs)
  604.     capPreviewRate(hwndCap, gbHaveHardware ? 33 : 0); 
  606.     // set live/overlay to default
  607.     vidcapSetLive(gbLive);
  608.     vidcapSetOverlay(gbOverlay);
  610.     strcat (szName, ",   ");
  611.     strcat (szName, szVersion);
  613.     statusUpdateStatus(ghWndStatus, 
  614.         gbHaveHardware ? szName : gachLastError);
  616.     return gbHaveHardware;
  617. }
  620. /*
  621.  * layout the main window. Put the toolbar at the top and the status
  622.  * line at the bottom, and then give all the rest to vidframe,
  623.  *  - it will centre or scroll the AVICAP window appropriately.
  624.  */
  625. void
  626. vidcapLayout(HWND hwnd)
  627. {
  628.     RECT rc;
  629.     RECT rw;
  630.     int cy;
  631.     int cyBorder, cxBorder;
  632.     int cyTotal;
  633.     int cxToolbar;
  634.     int cyMenuAndToolbarAndCaption;
  636.     gbInLayout = TRUE;  // So that we process WM_GETMINMAXINFO normally
  638.     /* for both the toolbar and status bar window,
  639.      * we want just one of the four borders. We do this
  640.      * by setting the WS_BORDER style, and sizing and positioning
  641.      * the window so that the 3 unwanted borders are outside the parent.
  642.      */
  643.     cyBorder = GetSystemMetrics(SM_CYBORDER);
  644.     cxBorder = GetSystemMetrics(SM_CXBORDER);
  646.     // Figure out the height of the menu, toolbar, and caption
  647.     GetWindowRect (hwnd, &rw);
  648.     GetClientRect (hwnd, &rc);
  650.     ClientToScreen (hwnd, (LPPOINT) &rc);
  651.     cyMenuAndToolbarAndCaption = (rc.top - rw.top) + TOOLBAR_HEIGHT;
  653.     cxToolbar = aPos[APP_NUMTOOLS - 1] + BUTTONWIDTH * 3;
  655.     if (gbAutoSizeFrame && gbHaveHardware && gCapStatus.uiImageWidth) {
  656.         cyTotal = gCapStatus.uiImageHeight +
  657.                 cyMenuAndToolbarAndCaption +
  658.                 (gbStatusBar ? statusGetHeight() : 0) +
  659.                 cyBorder * 2 + 
  660.                 12;     // vidFrame height
  661.         // Never make the frame smaller than the toolbar
  662.         if (gCapStatus.uiImageWidth >= (UINT) cxToolbar) {
  663.             SetWindowPos(
  664.                 hwnd,
  665.                 0, // placement-order handle
  666.                 0, // horizontal position
  667.                 0, // vertical position
  668.                 gCapStatus.uiImageWidth + cxBorder * 24, // width
  669.                 cyTotal, // height
  670.                 SWP_NOZORDER | SWP_NOMOVE  // window-positioning flags
  671.                 );
  672.         } else {
  673.             SetWindowPos(
  674.                 hwnd,
  675.                 0, // placement-order handle
  676.                 0, // horizontal position
  677.                 0, // vertical position
  678.                 cxToolbar, // width
  679.                 cyTotal, // height
  680.                 SWP_NOZORDER | SWP_NOMOVE  // window-positioning flags
  681.                 );
  682.         }
  683.     }
  685.     GetClientRect(hwnd, &rc);
  687.     if (gbToolBar) {
  688.         // put the toolbar at the top - in fact, just off the top so as to
  689.         // hide it's border
  690.         MoveWindow(
  691.             ghWndToolBar,
  692.             -cxBorder, -cyBorder,
  693.             RECTWIDTH(rc)+ (cxBorder * 2),
  694.             TOOLBAR_HEIGHT,
  695.             TRUE);
  696.         rc.top += (TOOLBAR_HEIGHT - cyBorder);
  697.     } else {
  698.         MoveWindow(ghWndToolBar, 0, 0, 0, 0, TRUE);
  699.     }
  701.     // status bar at the bottom
  702.     if (gbStatusBar) {
  703.         cy = statusGetHeight() + cyBorder;
  704.         MoveWindow(
  705.             ghWndStatus,
  706.             -cxBorder, rc.bottom - cy,
  707.             RECTWIDTH(rc) + (2 * cxBorder), cy + cyBorder,
  708.             TRUE);
  709.         rc.bottom -= cy;
  710.     } else {
  711.         MoveWindow(ghWndStatus, 0, 0, 0, 0, TRUE);
  712.     }
  714.     // rest of window goes to vidframe window
  715.     MoveWindow(
  716.         ghWndFrame,
  717.         rc.left, rc.top,
  718.         RECTWIDTH(rc), RECTHEIGHT(rc),
  719.         TRUE);
  721.     // Always layout the frame window, since it is aligned on a
  722.     // DWORD boundary for maximum codec drawing efficiency
  723.     vidframeLayout(ghWndFrame, ghWndCap);
  725.     gbInLayout = FALSE; 
  726. }
  728. /*
  729.  * initialise settings from the profile used before window creation time
  730.  */
  731. void
  732. vidcapReadProfile(void)
  733. {
  734.     // read defaults out of the registry
  735.     gbCentre = mmGetProfileFlag(gachAppTitle, "CenterImage", TRUE);
  736.     gbToolBar = mmGetProfileFlag(gachAppTitle, "ToolBar", TRUE);
  737.     gbStatusBar = mmGetProfileFlag(gachAppTitle, "StatusBar", TRUE);
  738.     gbAutoSizeFrame = mmGetProfileFlag(gachAppTitle, "AutoSizeFrame", TRUE);
  739.     gBackColour = mmGetProfileInt(gachAppTitle, "BackgroundColor", IDD_PrefsLtGrey);
  741.     gWinX = mmGetProfileInt(gachAppTitle, "WindowXPos", (UINT) CW_USEDEFAULT);
  742. if (gWinX != (UINT) CW_USEDEFAULT)
  743.      gWinX = LimitRange(gWinX, 0, GetSystemMetrics (SM_CXSCREEN) - 40);
  744.     gWinY = mmGetProfileInt(gachAppTitle, "WindowYPos", 0);
  745.     gWinY = LimitRange(gWinY, 0, GetSystemMetrics (SM_CYSCREEN) - 40);
  746.     gWinCX = mmGetProfileInt(gachAppTitle, "WindowWidth", 320);
  747.     gWinCX = LimitRange(gWinCX, 20, GetSystemMetrics (SM_CXSCREEN));
  748.     gWinCY = mmGetProfileInt(gachAppTitle, "WindowHeight", 240);
  749.     gWinCY = LimitRange(gWinCY, 20, GetSystemMetrics (SM_CYSCREEN));
  750.     gWinShow = mmGetProfileInt(gachAppTitle, "WindowShow", SW_SHOWDEFAULT);
  751.     gWinShow = LimitRange(gWinShow, SW_SHOWNORMAL, SW_SHOWDEFAULT);
  753.     gbOverlay = mmGetProfileInt(gachAppTitle, "OverlayWindow", FALSE);
  754.     gbLive = mmGetProfileInt(gachAppTitle, "LiveWindow", TRUE);
  755. }
  758. void
  759. vidcapWriteProfile(void)
  760. {
  761.     mmWriteProfileFlag(gachAppTitle, "CenterImage", gbCentre, TRUE);
  762.     mmWriteProfileFlag(gachAppTitle, "ToolBar", gbToolBar, TRUE);
  763.     mmWriteProfileFlag(gachAppTitle, "StatusBar", gbStatusBar, TRUE);
  764.     mmWriteProfileFlag(gachAppTitle, "AutoSizeFrame", gbAutoSizeFrame, TRUE);
  765.     mmWriteProfileInt(gachAppTitle,  "BackgroundColor", gBackColour, IDD_PrefsLtGrey);
  767.     mmWriteProfileInt(gachAppTitle, "WindowXPos", gWinX, (UINT) CW_USEDEFAULT);
  768.     mmWriteProfileInt(gachAppTitle, "WindowYPos", gWinY, 0);
  769.     mmWriteProfileInt(gachAppTitle, "WindowWidth", gWinCX, 320);
  770.     mmWriteProfileInt(gachAppTitle, "WindowHeight", gWinCY, 240);
  771.     mmWriteProfileInt(gachAppTitle, "WindowShow", gWinShow, SW_SHOWDEFAULT);
  773.     mmWriteProfileInt(gachAppTitle, "OverlayWindow", gbOverlay, FALSE);
  774.     mmWriteProfileInt(gachAppTitle, "LiveWindow", gbLive, TRUE);
  775. }
  777. /*
  778.  * initialise settings from the profile used AFTER window creation time
  779.  */
  780. void
  781. vidcapReadSettingsProfile(void)
  782. {
  783.     DWORD dwSize;
  784.     
  785.     mmGetProfileString(gachAppTitle, "CaptureFile", "",
  786.         gachCaptureFile, sizeof(gachCaptureFile));
  788.     mmGetProfileString(gachAppTitle, "MCIDevice", "VideoDisc",
  789.                 gachMCIDeviceName, sizeof(gachMCIDeviceName));
  791.     gCapParms.dwRequestMicroSecPerFrame = 
  792.                 mmGetProfileInt(gachAppTitle, "MicroSecPerFrame", 
  793.                 DEF_CAPTURE_RATE);
  795.     gCapParms.dwRequestMicroSecPerFrame = 
  796.                 mmGetProfileInt(gachAppTitle, "MicroSecPerFrame", 
  797.                 DEF_CAPTURE_RATE);
  799.     gCapParms.fCaptureAudio = mmGetProfileFlag(gachAppTitle, "CaptureAudio", 
  800.                 gCapStatus.fAudioHardware);
  802.     gCapParms.fLimitEnabled = mmGetProfileFlag(gachAppTitle, "LimitEnabled", 
  803.                 FALSE);
  805.     gCapParms.wTimeLimit = 
  806.                 mmGetProfileInt(gachAppTitle, "TimeLimit", 30);
  808.     gCapParms.fMCIControl= mmGetProfileFlag(gachAppTitle, "MCIControl", FALSE);
  810.     gCapParms.fStepMCIDevice= mmGetProfileFlag(gachAppTitle, "StepMCIDevice", FALSE);
  812.     gCapParms.dwMCIStartTime = 
  813.                 mmGetProfileInt(gachAppTitle, "MCIStartTime", 10000);
  815.     gCapParms.dwMCIStopTime = 
  816.                 mmGetProfileInt(gachAppTitle, "MCIStopTime", 20000);
  818.     gCapParms.fStepCaptureAt2x = mmGetProfileFlag(gachAppTitle, "StepCapture2x", 
  819.                 FALSE);
  821.     gCapParms.wStepCaptureAverageFrames = 
  822.                 mmGetProfileInt(gachAppTitle, "StepCaptureAverageFrames", 3);
  824.     gCapParms.AVStreamMaster = mmGetProfileInt (gachAppTitle, "AVStreamMaster",
  825.                 AVSTREAMMASTER_AUDIO);
  827.     gCapParms.fUsingDOSMemory = mmGetProfileFlag (gachAppTitle, "CaptureToDisk",
  828.                 TRUE);
  830.     gCapParms.dwIndexSize = 
  831.                 mmGetProfileInt(gachAppTitle, "IndexSize", 
  832.                 CAP_SMALL_INDEX);
  833.     
  834.     // Retrieve the saved audio format
  835.     // Ask the ACM what the largest known wave format is
  836.     acmMetrics(NULL,
  837.                ACM_METRIC_MAX_SIZE_FORMAT,
  838.                &dwSize);
  840.     // If a wave format was saved in the registry, use that size
  841.     dwSize = max (dwSize, mmGetProfileBinary(gachAppTitle, "WaveFormatBinary",
  842.    NULL,
  843.    NULL,
  844.    0));
  845.   
  846.     if (glpwfex = (LPWAVEFORMATEX) GlobalAllocPtr(GHND, dwSize)) {
  847. capGetAudioFormat(ghWndCap, glpwfex, (WORD)dwSize) ;
  848. mmGetProfileBinary(gachAppTitle, "WaveFormatBinary",
  849.    glpwfex,
  850.    glpwfex,
  851.    dwSize);
  853. // Do some sanity checking
  854. if (MMSYSERR_NOERROR == waveInOpen (NULL, WAVE_MAPPER,
  855.     glpwfex, 0, 0, WAVE_FORMAT_QUERY)) {
  856.     capSetAudioFormat(ghWndCap, glpwfex, (WORD)dwSize) ;
  857. } 
  858. GlobalFreePtr(glpwfex) ;
  859.     }
  860. }
  863. void
  864. vidcapWriteSettingsProfile(void)
  865. {
  866.     mmWriteProfileString(gachAppTitle, "CaptureFile", gachCaptureFile);
  868.     mmWriteProfileString(gachAppTitle, "MCIDevice", gachMCIDeviceName);
  870.     mmWriteProfileInt(gachAppTitle, "MicroSecPerFrame", 
  871.                 gCapParms.dwRequestMicroSecPerFrame, DEF_CAPTURE_RATE);
  873.     mmWriteProfileFlag(gachAppTitle, "CaptureAudio", 
  874.                 gCapParms.fCaptureAudio, gCapStatus.fAudioHardware);
  876.     mmWriteProfileFlag(gachAppTitle, "LimitEnabled", 
  877.                 gCapParms.fLimitEnabled, FALSE);
  879.     mmWriteProfileInt(gachAppTitle, "TimeLimit", 
  880.                 gCapParms.wTimeLimit, 30);
  882.     mmWriteProfileFlag(gachAppTitle, "MCIControl", 
  883.                 gCapParms.fMCIControl, FALSE);
  885.     mmWriteProfileFlag(gachAppTitle, "StepMCIDevice", 
  886.                 gCapParms.fStepMCIDevice, FALSE);
  888.     mmWriteProfileInt(gachAppTitle, "MCIStartTime", 
  889.                 gCapParms.dwMCIStartTime, 10000);
  891.     mmWriteProfileInt(gachAppTitle, "MCIStopTime", 
  892.                 gCapParms.dwMCIStopTime, 20000);
  894.     mmWriteProfileFlag(gachAppTitle, "StepCapture2x", 
  895.                 gCapParms.fStepCaptureAt2x, FALSE);
  897.     mmWriteProfileInt(gachAppTitle, "StepCaptureAverageFrames", 
  898.                 gCapParms.wStepCaptureAverageFrames, 3);
  900.     mmWriteProfileInt(gachAppTitle, "AVStreamMaster", 
  901.                 gCapParms.AVStreamMaster, AVSTREAMMASTER_AUDIO);
  903.     mmWriteProfileFlag(gachAppTitle, "CaptureToDisk", 
  904.                 gCapParms.fUsingDOSMemory, TRUE);
  906.     mmWriteProfileInt(gachAppTitle, "IndexSize", 
  907.                 gCapParms.dwIndexSize, CAP_SMALL_INDEX);
  909.     // The audio format is written whenever it is changed via dlg
  910. }
  915. /* --- error/status functions -------------------------------------------*/
  917. /*
  918.  * put up a message box loading a string from the
  919.  * resource file
  920.  */
  921. int
  922. MessageBoxID(UINT idString, UINT fuStyle)
  923. {
  924.     char achMessage[256];   // max message length
  926.     LoadString(ghInstApp, idString, achMessage, sizeof(achMessage));
  928.     return MessageBox(ghWndMain, achMessage, gachAppTitle, fuStyle);
  929. }
  933. //
  934. // ErrorCallbackProc: Error Callback Function
  935. //
  936. LRESULT FAR PASCAL ErrorCallbackProc(HWND hWnd, int nErrID, LPSTR lpErrorText)
  937. {
  938. ////////////////////////////////////////////////////////////////////////
  939. //  hWnd:          Application main window handle
  940. //  nErrID:        Error code for the encountered error
  941. //  lpErrorText:   Error text string for the encountered error
  942. ////////////////////////////////////////////////////////////////////////
  944.     if (!ghWndMain)
  945.         return FALSE;
  947.     if (nErrID == 0)            // Starting a new major function
  948.         return TRUE;            // Clear out old errors...
  950.     // save the error message for use in NoHardwareDlgProc
  951.     lstrcpy(gachLastError, lpErrorText);
  953.     // Show the error ID and text
  955.     MessageBox(hWnd, lpErrorText, gachAppTitle,
  956.                 MB_OK | MB_ICONEXCLAMATION) ;
  958.     return (LRESULT) TRUE ;
  959. }
  962. //
  963. // StatusCallbackProc: Status Callback Function
  964. //
  965. LRESULT FAR PASCAL StatusCallbackProc(HWND hWnd, int nID, LPSTR lpStatusText)
  966. {
  967. ////////////////////////////////////////////////////////////////////////
  968. //  hWnd:           Application main window handle
  969. //  nID:            Status code for the current status
  970. //  lpStatusText:   Status text string for the current status
  971. ////////////////////////////////////////////////////////////////////////
  973.     static int CurrentID;
  975.     if (!ghWndMain) {
  976.         return FALSE;
  977.     }
  979.     // the CAP_END message sometimes overwrites a useful
  980.     // statistics message.
  981.     if (nID == IDS_CAP_END) {
  982.         if ((CurrentID == IDS_CAP_STAT_VIDEOAUDIO) ||
  983.             (CurrentID == IDS_CAP_STAT_VIDEOONLY)) {
  985.             return(TRUE);
  986.         }
  987.     }
  988.     CurrentID = nID;
  991.     statusUpdateStatus(ghWndStatus, lpStatusText);
  993.     return (LRESULT) TRUE ;
  994. }
  997. //
  998. // YieldCallbackProc: Status Callback Function
  999. // (Only used for Scrncap.drv driver)
  1000. //
  1001. LRESULT FAR PASCAL YieldCallbackProc(HWND hWnd)
  1002. {
  1003. ////////////////////////////////////////////////////////////////////////
  1004. //  hWnd:           Application main window handle
  1005. ////////////////////////////////////////////////////////////////////////
  1007.     MSG msg;
  1009.     if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
  1010.         TranslateMessage(&msg);
  1011.         DispatchMessage(&msg);
  1012.     }
  1014.     // Return TRUE to continue capturing
  1015.     return (LRESULT) TRUE;
  1016. }
  1020. /*
  1021.  * load a string from the string table and return
  1022.  * a pointer to it for temporary use. Each call
  1023.  * overwrites the previous
  1024.  */
  1025. LPSTR
  1026. tmpString(UINT idString)
  1027. {
  1028.     static char ach[350];
  1030.     LoadString(ghInstApp, idString, ach, sizeof(ach));
  1032.     // ensure null terminated
  1033.     ach[sizeof(ach) -1] = 0;
  1035.     return(ach);
  1036. }
  1041. /* --- connect to and init hardware ------------------------------------- */
  1044. void
  1045. vidcapSetLive(BOOL bLive)
  1046. {
  1047.     capPreview(ghWndCap, bLive);
  1048.     toolbarModifyState(ghWndToolBar, BTN_LIVE, bLive? BTNST_DOWN : BTNST_UP);
  1049.     CheckMenuItem(GetMenu(ghWndMain), IDM_O_PREVIEW,
  1050.         MF_BYCOMMAND | (bLive ? MF_CHECKED : MF_UNCHECKED));
  1052.     gbLive = bLive;
  1054.     if (bLive == TRUE) {
  1055.         vidcapSetOverlay(FALSE);
  1056.     }
  1057. }
  1059. void
  1060. vidcapSetOverlay(BOOL bOverlay)
  1061. {
  1062.     if (!gCapDriverCaps.fHasOverlay) {
  1063.         CheckMenuItem(GetMenu(ghWndMain), IDM_O_OVERLAY,
  1064.             MF_BYCOMMAND | MF_UNCHECKED);
  1065.         gbOverlay = FALSE;
  1066.         return;
  1067.     }
  1069.     capOverlay(ghWndCap, bOverlay);
  1070.     toolbarModifyState(ghWndToolBar, BTN_OVERLAY, bOverlay ? BTNST_DOWN : BTNST_UP);
  1071.     CheckMenuItem(GetMenu(ghWndMain), IDM_O_OVERLAY,
  1072.         MF_BYCOMMAND | (bOverlay ? MF_CHECKED : MF_UNCHECKED));
  1074.     gbOverlay = bOverlay;
  1076.     if (bOverlay == TRUE) {
  1077.         vidcapSetLive(FALSE);
  1078.     }
  1079. }
  1081. void
  1082. vidcapSetCaptureFile(LPSTR pFileName)
  1083. {
  1084.     char achBuffer[_MAX_PATH];
  1086.     if ((pFileName != NULL) && (lstrlen(pFileName)  > 0)) {
  1087.         // record the capture filename
  1088.         if (lstrcmp(gachCaptureFile, pFileName)) {
  1089.             lstrcpy(gachCaptureFile, pFileName);
  1090.         }
  1092.         // and set window title
  1093.         wsprintf(achBuffer, "%s - %s", gachAppTitle, pFileName);
  1094.     } else {
  1095.         gachCaptureFile[0] = 0;
  1096.         lstrcpy(achBuffer, gachAppTitle);
  1097.     }
  1099.     capFileSetCaptureFile(ghWndCap, gachCaptureFile);
  1100.     SetWindowText(ghWndMain, achBuffer);
  1101. }
  1103. /* --- winproc and message handling --------------------------------------- */
  1105. /*
  1106.  * called from WM_COMMAND processing if the
  1107.  * message is from the toolbar. iButton contains the
  1108.  * button ID in the lower 8 bits, and the flags in the upper 8 bits/
  1109.  */
  1110. LONG FAR PASCAL
  1111. toolbarCommand (HWND hWnd, int iButton, HWND hwndToolbar)
  1112. {
  1113.     int iBtnPos, iState, iActivity, iString;
  1116.     // check repeat bit
  1117.     if (iButton & BTN_REPEAT) {
  1118.         return(0);
  1119.     }
  1120.     iButton &= 0xff;
  1122.     iBtnPos = toolbarIndexFromButton(hwndToolbar, iButton);
  1123.     iState = toolbarStateFromButton(hwndToolbar, iButton);
  1124.     iActivity = toolbarActivityFromButton(hwndToolbar, iButton);
  1125.     iString = toolbarStringFromIndex(hwndToolbar, iBtnPos);
  1127.     switch(iActivity) {
  1129.     case BTNACT_MOUSEDOWN:
  1130.     case BTNACT_KEYDOWN:
  1131.     case BTNACT_MOUSEMOVEON:
  1132.         statusUpdateStatus(ghWndStatus, MAKEINTRESOURCE(iString));
  1133.         break;
  1135.     case BTNACT_MOUSEMOVEOFF:
  1136.         statusUpdateStatus(ghWndStatus, NULL);
  1137.         break;
  1139.     case BTNACT_MOUSEUP:
  1140.     case BTNACT_KEYUP:
  1142.         statusUpdateStatus(ghWndStatus, NULL);
  1143.         switch(iButton) {
  1144.         case BTN_SETFILE:
  1145.             SendMessage(hWnd, WM_COMMAND,
  1146.                 GET_WM_COMMAND_MPS(IDM_F_SETCAPTUREFILE, NULL, 0));
  1147.                 break;
  1149.         case BTN_EDITCAP:
  1150.             // edit captured video
  1151.             SendMessage(hWnd, WM_COMMAND,
  1152.                 GET_WM_COMMAND_MPS(IDM_F_EDITVIDEO, NULL, 0));
  1153.             break;
  1155.         case BTN_LIVE:
  1156.             SendMessage(hWnd,WM_COMMAND,
  1157.                 GET_WM_COMMAND_MPS(IDM_O_PREVIEW, NULL, 0));
  1158.             break;
  1160.         case BTN_CAPFRAME:
  1161.             SendMessage(hWnd, WM_COMMAND,
  1162.                 GET_WM_COMMAND_MPS(IDM_C_CAPTUREFRAME, NULL, 0));
  1163.             break;
  1165.         case BTN_CAPSEL:
  1166.             // capture selected frames
  1167.             SendMessage(hWnd, WM_COMMAND,
  1168.                 GET_WM_COMMAND_MPS(IDM_C_CAPSEL, NULL, 0));
  1169.             break;
  1171.         case BTN_CAPAVI:
  1172.             SendMessage(hWnd,WM_COMMAND,
  1173.                 GET_WM_COMMAND_MPS(IDM_C_CAPTUREVIDEO, NULL, 0));
  1174.             break;
  1176.         case BTN_CAPPAL:
  1177.             SendMessage(hWnd, WM_COMMAND,
  1178.                 GET_WM_COMMAND_MPS(IDM_C_PALETTE, NULL, 0));
  1179.             break;
  1181.         case BTN_OVERLAY:
  1182.             SendMessage(hWnd, WM_COMMAND,
  1183.                 GET_WM_COMMAND_MPS(IDM_O_OVERLAY, NULL, 0));
  1184.             break;
  1185.         }
  1186.         break;
  1187.     }
  1188.     return(0);
  1189. }
  1192. /*
  1193.  * Put up a dialog to allow the user to select a capture file.
  1194.  */
  1195. LONG FAR PASCAL
  1196. cmdSetCaptureFile(HWND hWnd)
  1197. {
  1198.     OPENFILENAME ofn ;
  1199.     LPSTR p;
  1200.     char         achFileName[_MAX_PATH];
  1201.     char         achBuffer[_MAX_PATH] ;
  1202.     UINT         wError ;
  1203.     HANDLE hFilter;
  1204.     int oldhelpid;
  1207.     // Get current capture file name and
  1208.     // then try to get the new capture file name
  1209.     if (wError = capFileGetCaptureFile(ghWndCap, achFileName,
  1210.                                 sizeof(achFileName))) {
  1212.         // Get just the path info
  1213.         // Terminate the full path at the last backslash
  1214.         lstrcpy (achBuffer, achFileName);
  1215.         for (p = achBuffer + lstrlen(achBuffer); p > achBuffer; p--) {
  1216.             if (*p == '\') {
  1217.                 *(p+1) = '';
  1218.                 break;
  1219.             }
  1220.         }
  1222.         _fmemset(&ofn, 0, sizeof(OPENFILENAME)) ;
  1223.         ofn.lStructSize = sizeof(OPENFILENAME) ;
  1224.         ofn.hwndOwner = hWnd ;
  1226.         //load filters from resource stringtable
  1227.         hFilter = FindResource(ghInstApp, MAKEINTRESOURCE(ID_FILTER_AVI), RT_RCDATA);
  1228.         if ((hFilter = LoadResource(ghInstApp, hFilter)) == NULL) {
  1229.             ofn.lpstrFilter = NULL;
  1230.         } else {
  1231.             ofn.lpstrFilter = LockResource(hFilter);
  1232.         }
  1234.         ofn.nFilterIndex = 0 ;
  1235.         ofn.lpstrFile = achFileName ;
  1236.         ofn.nMaxFile = sizeof(achFileName) ;
  1237.         ofn.lpstrFileTitle = NULL;
  1238.         ofn.lpstrTitle = tmpString(IDS_TITLE_SETCAPTUREFILE);
  1239.         ofn.nMaxFileTitle = 0 ;
  1240.         ofn.lpstrInitialDir = achBuffer;
  1241.         ofn.Flags =
  1242.         OFN_HIDEREADONLY |
  1243.         OFN_NOREADONLYRETURN |
  1244.         OFN_PATHMUSTEXIST ;
  1246.         // set help context for dialog
  1247.         oldhelpid = SetCurrentHelpContext(IDA_SETCAPFILE);
  1249.         if (GetOpenFileName(&ofn)) {
  1250.             OFSTRUCT os;
  1252.             vidcapSetCaptureFile(achFileName);
  1255.             /*
  1256.              * if this is a new file, then invite the user to
  1257.              * allocate some space
  1258.              */
  1259.             if (OpenFile(achFileName, &os, OF_EXIST) == HFILE_ERROR) {
  1261.                 /*
  1262.                  * show the allocate file space dialog to encourage
  1263.                  * the user to pre-allocate space
  1264.                  */
  1265.                 if (DoDialog(hWnd, IDD_AllocCapFileSpace, AllocCapFileProc, 0)) {
  1267.     // ensure repaint after dismissing dialog before
  1268.     // possibly lengthy operation
  1269.     UpdateWindow(ghWndMain);
  1271.                     // If user has hit OK then alloc requested capture file space
  1272.                     if (! capFileAlloc(ghWndCap, (long) gwCapFileSize * ONEMEG)) {
  1273.                         MessageBoxID(IDS_ERR_CANT_PREALLOC,
  1274.                                     MB_OK | MB_ICONEXCLAMATION) ;
  1275.                     }
  1276.                 }
  1277.             }
  1279.         }
  1281.         // restore old help context
  1282.         SetCurrentHelpContext(oldhelpid);
  1284.         if (hFilter) {
  1285.             UnlockResource(hFilter);
  1286.         }
  1288.     }
  1289.     return(0);
  1290. }
  1292. /*
  1293.  * query the user for a filename, and then save the captured video
  1294.  * to that file
  1295.  */
  1296. LONG FAR PASCAL
  1297. cmdSaveVideoAs(HWND hWnd)
  1298. {
  1299.     OPENFILENAME ofn ;
  1300.     char         achFileName[_MAX_PATH];
  1301.     UINT         wError ;
  1302.     HANDLE       hFilter;
  1303.     int          oldhelpid;
  1307.     // Get the current capture file name and
  1308.     // then get the substitute file name to save video in
  1309.     if (wError = capFileGetCaptureFile(ghWndCap, achFileName, sizeof(achFileName))) {
  1311.         _fmemset(&ofn, 0, sizeof(OPENFILENAME)) ;
  1312.         ofn.lStructSize = sizeof(OPENFILENAME) ;
  1313.         ofn.hwndOwner = hWnd ;
  1315.         //load filters from resource stringtable
  1316.         hFilter = FindResource(ghInstApp, MAKEINTRESOURCE(ID_FILTER_AVI), RT_RCDATA);
  1317.         if ((hFilter = LoadResource(ghInstApp, hFilter)) == NULL) {
  1318.             ofn.lpstrFilter = NULL;
  1319.         } else {
  1320.             ofn.lpstrFilter = LockResource(hFilter);
  1321.         }
  1323.         ofn.nFilterIndex = 0 ;
  1324.         ofn.lpstrFile = achFileName ;
  1325.         ofn.nMaxFile = sizeof(achFileName) ;
  1326.         ofn.lpstrFileTitle = NULL ;
  1327.         ofn.lpstrTitle = tmpString(IDS_TITLE_SAVEAS);
  1328.         ofn.nMaxFileTitle = 0 ;
  1329.         ofn.lpstrInitialDir = NULL ;
  1330.         ofn.Flags =
  1331.         OFN_OVERWRITEPROMPT |  OFN_PATHMUSTEXIST ;
  1334.         // set help context
  1335.         oldhelpid = SetCurrentHelpContext(IDA_SAVECAPFILE);
  1337.         if (GetSaveFileName(&ofn)) {
  1338.             // If the user has hit OK then set save file name
  1339.             capFileSaveAs(ghWndCap, achFileName) ;
  1340.         }
  1342.         SetCurrentHelpContext(oldhelpid);
  1344.         if (hFilter) {
  1345.             UnlockResource(hFilter);
  1346.         }
  1347.     }
  1348.     return(0);
  1349. }
  1352. /*
  1353.  * Put up a dialog to allow the user to select a palette file and then
  1354.  * load that palette
  1355.  */
  1356. LONG FAR PASCAL
  1357. cmdLoadPalette(HWND hWnd)
  1358. {
  1359.     OPENFILENAME ofn ;
  1360.     char         achFileName[_MAX_PATH];
  1361.     HANDLE       hFilter;
  1362.     int          oldhelpid;
  1366.     achFileName[0] = 0;
  1368.     _fmemset(&ofn, 0, sizeof(OPENFILENAME));
  1369.     ofn.lStructSize = sizeof(OPENFILENAME);
  1370.     ofn.hwndOwner = hWnd;
  1372.     //load filters from resource stringtable
  1373.     hFilter = FindResource(ghInstApp, MAKEINTRESOURCE(ID_FILTER_PALETTE), RT_RCDATA);
  1374.     if ((hFilter = LoadResource(ghInstApp, hFilter)) == NULL) {
  1375.         ofn.lpstrFilter = NULL;
  1376.     } else {
  1377.         ofn.lpstrFilter = LockResource(hFilter);
  1378.     }
  1380.     ofn.nFilterIndex = 1;
  1381.     ofn.lpstrFile = achFileName;
  1382.     ofn.nMaxFile = sizeof(achFileName);
  1383.     ofn.lpstrFileTitle = NULL;
  1384.     ofn.lpstrTitle = tmpString(IDS_TITLE_LOADPALETTE);
  1385.     ofn.nMaxFileTitle = 0;
  1386.     ofn.lpstrInitialDir = NULL;
  1387.     ofn.Flags =
  1388.     OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
  1391.     // set help context id
  1392.     oldhelpid = SetCurrentHelpContext(IDA_LOADPAL);
  1394.     if (GetOpenFileName(&ofn)) {
  1395.         // If the user has hit OK then load palette
  1396.         capPaletteOpen(ghWndCap, achFileName);
  1397.     }
  1399.     SetCurrentHelpContext(oldhelpid);
  1401.     if (hFilter) {
  1402.         UnlockResource(hFilter);
  1403.     }
  1404.     return(0);
  1405. }
  1407. /*
  1408.  * query the user for a filename, and then save the current palette
  1409.  * to that file
  1410.  */
  1411. LONG FAR PASCAL
  1412. cmdSavePalette(HWND hWnd)
  1413. {
  1414.     OPENFILENAME ofn ;
  1415.     char         achFileName[_MAX_PATH];
  1416.     HANDLE       hFilter;
  1417.     int          oldhelpid;
  1420.     achFileName[0] = 0;
  1422.     _fmemset(&ofn, 0, sizeof(OPENFILENAME)) ;
  1423.     ofn.lStructSize = sizeof(OPENFILENAME) ;
  1424.     ofn.hwndOwner = hWnd ;
  1426.     //load filters from resource stringtable
  1427.     hFilter = FindResource(ghInstApp, MAKEINTRESOURCE(ID_FILTER_PALETTE), RT_RCDATA);
  1428.     if ((hFilter = LoadResource(ghInstApp, hFilter)) == NULL) {
  1429.         ofn.lpstrFilter = NULL;
  1430.     } else {
  1431.         ofn.lpstrFilter = LockResource(hFilter);
  1432.     }
  1434.     ofn.nFilterIndex = 1;
  1435.     ofn.lpstrFile = achFileName;
  1436.     ofn.nMaxFile = sizeof(achFileName);
  1437.     ofn.lpstrFileTitle = NULL;
  1438.     ofn.lpstrTitle = tmpString(IDS_TITLE_SAVEPALETTE);
  1439.     ofn.nMaxFileTitle = 0;
  1440.     ofn.lpstrInitialDir = NULL;
  1441.     ofn.Flags =
  1442.     OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
  1444.     // set help context for F1 key
  1445.     oldhelpid = SetCurrentHelpContext(IDA_SAVEPAL);
  1447.     if (GetSaveFileName(&ofn)) {
  1448.         // If the user has hit OK then set save file name
  1449.         capPaletteSave(ghWndCap, achFileName);
  1450.     }
  1452.     SetCurrentHelpContext(oldhelpid);
  1454.     if (hFilter) {
  1455.         UnlockResource(hFilter);
  1456.     }
  1458.     return(0);
  1459. }
  1462. /*
  1463.  * query the user for a filename, and then save the current frame
  1464.  * to that file
  1465.  */
  1466. LONG FAR PASCAL
  1467. cmdSaveDIB(HWND hWnd)
  1468. {
  1469.     OPENFILENAME ofn ;
  1470.     char         achFileName[_MAX_PATH];
  1471.     HANDLE       hFilter;
  1472.     int          oldhelpid;
  1475.     achFileName[0] = 0;
  1477.     _fmemset(&ofn, 0, sizeof(OPENFILENAME)) ;
  1478.     ofn.lStructSize = sizeof(OPENFILENAME) ;
  1479.     ofn.hwndOwner = hWnd ;
  1481.     //load filters from resource stringtable
  1482.     hFilter = FindResource(ghInstApp, MAKEINTRESOURCE(ID_FILTER_DIB), RT_RCDATA);
  1483.     if ((hFilter = LoadResource(ghInstApp, hFilter)) == NULL) {
  1484.         ofn.lpstrFilter = NULL;
  1485.     } else {
  1486.         ofn.lpstrFilter = LockResource(hFilter);
  1487.     }
  1489.     ofn.nFilterIndex = 1;
  1490.     ofn.lpstrFile = achFileName;
  1491.     ofn.nMaxFile = sizeof(achFileName);
  1492.     ofn.lpstrFileTitle = NULL;
  1493.     ofn.lpstrTitle = tmpString(IDS_TITLE_SAVEDIB);
  1494.     ofn.nMaxFileTitle = 0;
  1495.     ofn.lpstrInitialDir = NULL;
  1496.     ofn.Flags =
  1497.     OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
  1499.     // set help context for F1 handling
  1500.     oldhelpid = SetCurrentHelpContext(IDA_SAVEDIB);
  1502.     if (GetSaveFileName(&ofn)) {
  1504.         // If the user has hit OK then set save file name
  1505.         capFileSaveDIB(ghWndCap, achFileName);
  1506.     }
  1508.     SetCurrentHelpContext(oldhelpid);
  1510.     if (hFilter) {
  1511.         UnlockResource(hFilter);
  1512.     }
  1514.     return(0);
  1515. }
  1517. //
  1518. // MenuProc: Processes All Menu-based Operations
  1519. //
  1520. long FAR PASCAL MenuProc(HWND hWnd, UINT wParam, LONG lParam)
  1521. {
  1522. ////////////////////////////////////////////////////////////////////////
  1523. //  hWnd:      Application main window handle
  1524. //  hMenu:     Application menu handle
  1525. //  wParam:    Menu option
  1526. //  lParam:    Additional info for any menu option
  1527. ////////////////////////////////////////////////////////////////////////
  1529.     BOOL         fResult ;
  1530.     DWORD        dwSize ;
  1531.     int          oldhelpid;
  1533.     HMENU hMenu = GetMenu(hWnd) ;
  1535.     switch (GET_WM_COMMAND_ID(wParam, lParam)) {
  1537. case IDC_TOOLBAR:
  1538.             return toolbarCommand(hWnd, GET_WM_COMMAND_CMD(wParam, lParam), ghWndToolBar);
  1540. /* --- file --- */
  1541.         case IDM_F_SETCAPTUREFILE:
  1542.             return cmdSetCaptureFile(hWnd);
  1544.         case IDM_F_SAVEVIDEOAS:
  1545.             return cmdSaveVideoAs(hWnd);
  1546.             break;
  1548.         case IDM_F_ALLOCATESPACE:
  1549.             if (DoDialog(hWnd, IDD_AllocCapFileSpace, AllocCapFileProc, 0)) {
  1551. // ensure repaint after dismissing dialog before
  1552. // possibly lengthy operation
  1553. UpdateWindow(ghWndMain);
  1556.                 // If user has hit OK then alloc requested capture file space
  1557.                 if (! capFileAlloc(ghWndCap, (long) gwCapFileSize * ONEMEG)) {
  1558.                     MessageBoxID(IDS_ERR_CANT_PREALLOC,
  1559.                                 MB_OK | MB_ICONEXCLAMATION) ;
  1560.                 }
  1561.             }
  1562.             break ;
  1564.         case IDM_F_EXIT:
  1565.             DestroyWindow(hWnd) ;
  1566.             break;
  1568.         case IDM_F_LOADPALETTE:
  1569.             return cmdLoadPalette(hWnd);
  1571.         case IDM_F_SAVEPALETTE:
  1572.             return cmdSavePalette(hWnd);
  1574.         case IDM_F_SAVEFRAME:
  1575.             return cmdSaveDIB(hWnd);
  1577.         case IDM_F_EDITVIDEO:
  1578.         {
  1579.             char achCmdLine[256];
  1580.             UINT        u;
  1581.             BOOL f = TRUE; /* assume the best */
  1582.             HCURSOR     hOldCursor;
  1584.             /* build up the command line "AviEdit -n filename" */
  1585.             if (lstrlen(gachCaptureFile) > 0) {
  1586.                 lstrcpy(achCmdLine,"VIDEdit -n ");
  1587.                 lstrcat(achCmdLine, gachCaptureFile);
  1589.                 hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
  1590.                 u = WinExec(achCmdLine, SW_SHOWNORMAL);
  1591.                 if (u < 32){
  1592.              /* report error on forking VidEdit */
  1593.                     MessageBoxID(IDS_ERR_VIDEDIT, MB_OK|MB_ICONEXCLAMATION);
  1594.              f = FALSE;
  1595.                 }
  1597.                 SetCursor(hOldCursor);
  1598.             }
  1599.             return f;
  1601.         }
  1604. /* --- edit --- */
  1606.         case IDM_E_COPY:
  1607.             capEditCopy(ghWndCap) ;
  1608.             break;
  1610.         case IDM_E_PASTEPALETTE:
  1611.             capPalettePaste(ghWndCap) ;
  1612.             break;
  1614.         case IDM_E_PREFS:
  1615.             {
  1616.                 if (DoDialog(hWnd, IDD_Prefs, PrefsDlgProc, 0)) {
  1618.                         // write prefs to profile
  1620.                         // force new brush
  1621.                         vidframeSetBrush(ghWndFrame, gBackColour);
  1623.                         // re-do layout
  1624.                         vidcapLayout(hWnd);
  1626.                 }
  1627.             }
  1628.             break;
  1630. /* --- options --- */
  1632.         case IDM_O_PREVIEW:
  1633.             // Toggle Preview
  1634.          capGetStatus(ghWndCap, &gCapStatus, sizeof(CAPSTATUS)) ;
  1635.             vidcapSetLive(!gCapStatus.fLiveWindow) ;
  1636.             break;
  1638.         case IDM_O_OVERLAY:
  1639.             // Toggle Overlay
  1640.          capGetStatus(ghWndCap, &gCapStatus, sizeof(CAPSTATUS)) ;
  1641.             vidcapSetOverlay(!gCapStatus.fOverlayWindow);
  1642.             break ;
  1644.         case IDM_O_AUDIOFORMAT:
  1645. #ifdef  USE_ACM
  1646.             {
  1647.                 ACMFORMATCHOOSE cfmt;
  1648.                 static BOOL fDialogUp = FALSE;
  1650.                 if (fDialogUp)
  1651.                     return FALSE;
  1653.                 fDialogUp = TRUE;
  1654.                 // Ask the ACM what the largest wave format is.....
  1655.                 acmMetrics(NULL,
  1656.                             ACM_METRIC_MAX_SIZE_FORMAT,
  1657.                             &dwSize);
  1659.                 // Get the current audio format
  1660.                 dwSize = max (dwSize, capGetAudioFormatSize (ghWndCap));
  1661.                 if (glpwfex = (LPWAVEFORMATEX) GlobalAllocPtr(GHND, dwSize)) {
  1662.                     capGetAudioFormat(ghWndCap, glpwfex, (WORD)dwSize) ;
  1664.     _fmemset (&cfmt, 0, sizeof (ACMFORMATCHOOSE));
  1665.     cfmt.cbStruct = sizeof (ACMFORMATCHOOSE);
  1666.     cfmt.fdwStyle =  ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT;
  1667.     cfmt.fdwEnum =   ACM_FORMATENUMF_HARDWARE |
  1668.      ACM_FORMATENUMF_INPUT;
  1669.     cfmt.hwndOwner = hWnd;
  1670.     cfmt.pwfx =     glpwfex;
  1671.     cfmt.cbwfx =    dwSize;
  1673.     //oldhelpid = SetCurrentHelpContext(IDA_AUDIOSETUP);
  1674.     if (!acmFormatChoose(&cfmt)) {
  1675. capSetAudioFormat(ghWndCap, glpwfex, (WORD)glpwfex->cbSize +
  1676.   sizeof (WAVEFORMATEX)) ;
  1677. mmWriteProfileBinary(gachAppTitle, "WaveFormatBinary",
  1678.      (LPVOID) glpwfex, glpwfex->cbSize +
  1679.      sizeof (WAVEFORMATEX));
  1680.     }
  1681.     //SetCurrentHelpContext(oldhelpid);
  1683.     GlobalFreePtr(glpwfex) ;
  1684. }
  1685.                 fDialogUp = FALSE;
  1686.             }
  1687. #else
  1688.             {
  1689.                 // Get current audio format and then find required format
  1690.                 dwSize = capGetAudioFormatSize (ghWndCap);  
  1691.                 glpwfex = (LPWAVEFORMATEX) GlobalAllocPtr(GHND, dwSize) ;
  1692.                 capGetAudioFormat(ghWndCap, glpwfex, (WORD)dwSize) ;
  1694.                 if (DoDialog(hWnd, IDD_AudioFormat, AudioFormatProc, 0)) {
  1695.                         // If the user has hit OK, set the new audio format
  1696.                         capSetAudioFormat(ghWndCap, glpwfex, (WORD)dwSize) ;
  1697. mmWriteProfileBinary(gachAppTitle, "WaveFormatBinary",
  1698.  (LPVOID) glpwfex, dwSize);
  1699.                 }
  1700.                 GlobalFreePtr(glpwfex) ;
  1701.             }
  1702. #endif
  1703.             break ;
  1705.         case IDM_O_VIDEOFORMAT:
  1706.             if (gCapDriverCaps.fHasDlgVideoFormat) {
  1707.                 // Only if the driver has a "Video Format" dialog box
  1708.                 oldhelpid = SetCurrentHelpContext(IDA_VIDFORMAT);
  1709.                 if (capDlgVideoFormat(ghWndCap)) {  // If successful,
  1710.                     // Get the new image dimension and center capture window
  1711.                     capGetStatus(ghWndCap, &gCapStatus, sizeof(CAPSTATUS)) ;
  1712.                     vidcapLayout(hWnd);
  1713.                 }
  1714.                 SetCurrentHelpContext(oldhelpid);
  1715.             }
  1716.             break;
  1718.         case IDM_O_VIDEOSOURCE:
  1719.             if (gCapDriverCaps.fHasDlgVideoSource) {
  1720.                 // Only if the driver has a "Video Source" dialog box
  1721.                 oldhelpid = SetCurrentHelpContext(IDA_VIDSOURCE);
  1722.                 capDlgVideoSource(ghWndCap) ;
  1723.                 capGetStatus(ghWndCap, &gCapStatus, sizeof(CAPSTATUS)) ;
  1724.                 vidcapLayout(hWnd);
  1725.                 SetCurrentHelpContext(oldhelpid);
  1726.             }
  1727.             break ;
  1729.         case IDM_O_VIDEODISPLAY:
  1730.             if (gCapDriverCaps.fHasDlgVideoDisplay) {
  1731.                 // Only if the driver has a "Video Display" dialog box
  1732.                 oldhelpid = SetCurrentHelpContext(IDA_VIDDISPLAY);
  1733.                 capDlgVideoDisplay(ghWndCap) ;
  1734.                 capGetStatus(ghWndCap, &gCapStatus, sizeof(CAPSTATUS)) ;
  1735.                 SetCurrentHelpContext(oldhelpid);
  1736.             }
  1737.             break ;
  1739.         case IDM_O_CHOOSECOMPRESSOR:
  1740.             oldhelpid = SetCurrentHelpContext(IDA_COMPRESSION);
  1741.             capDlgVideoCompression(ghWndCap);
  1742.             SetCurrentHelpContext(oldhelpid);
  1743.             break;
  1745.         // Select a driver to activate
  1746.         case IDM_O_DRIVER0:
  1747.         case IDM_O_DRIVER1:
  1748.         case IDM_O_DRIVER2:
  1749.         case IDM_O_DRIVER3:
  1750.         case IDM_O_DRIVER4:
  1751.         case IDM_O_DRIVER5:
  1752.         case IDM_O_DRIVER6:
  1753.         case IDM_O_DRIVER7:
  1754.         case IDM_O_DRIVER8:
  1755.         case IDM_O_DRIVER9:
  1756.             vidcapInitHardware(ghWndMain, ghWndCap, wParam - IDM_O_DRIVER0);
  1757.             break;
  1759. /* --- capture --- */
  1762.         case IDM_C_PALETTE:
  1763.             if (DoDialog(hWnd, IDD_MakePalette, MakePaletteProc, 0)) {
  1764.                 // Palette is created within the dialog
  1765.                 bDefaultPalette = FALSE;
  1766.             }
  1767.             break;
  1769.         case IDM_C_CAPTUREVIDEO:
  1771.             // warn user if he is still using the default palette
  1772.             if (bDefaultPalette) {
  1774. LPBITMAPINFOHEADER lpbi;
  1775. int sz;
  1777. // fUsingDefaultPalette will be TRUE even if the
  1778. // current capture format is non-palettised. This is a
  1779. // bizarre decision of Jay's.
  1781. sz = (int)capGetVideoFormatSize(ghWndCap);
  1782. lpbi = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, sz);
  1784. if (lpbi) {    // We can warn s/he
  1785.     if (capGetVideoFormat(ghWndCap, lpbi, sz) &&
  1786. (lpbi->biCompression == BI_RGB) &&
  1787. (lpbi->biBitCount <= 8)) {
  1789. CAPSTATUS cs;
  1791. // if we've warned him once, we can forget it
  1792. bDefaultPalette = FALSE;
  1794. capGetStatus(ghWndCap, &cs, sizeof(cs));
  1796. if (cs.fUsingDefaultPalette) {
  1798.     if (MessageBoxID(IDS_WARN_DEFAULT_PALETTE,
  1799.              MB_OKCANCEL| MB_ICONEXCLAMATION)== IDCANCEL) {
  1800. break;
  1801.     }
  1802. }
  1803.     }
  1804.     LocalFree(lpbi);
  1805. }
  1806.             }
  1808.             // Invoke a Dlg box to setup all the params
  1809.             if (DoDialog(hWnd, IDD_CapSetUp, CapSetUpProc, 0)) {
  1811.                 // set the defaults we won't bother the user with
  1812.                 gCapParms.fMakeUserHitOKToCapture = !gCapParms.fMCIControl;
  1813.                 gCapParms.wPercentDropForError = 10;
  1815.                 // fUsingDOSMemory is obsolete, but we use it here as
  1816.                 // a flag which is TRUE if "CapturingToDisk"
  1817.                 // The number of video buffers should be enough to get through
  1818.                 // disk seeks and thermal recalibrations if "CapturingToDisk"
  1819.                 // If "CapturingToMemory", get as many buffers as we can.
  1821.                 gCapParms.wNumVideoRequested = 
  1822.                         gCapParms.fUsingDOSMemory ? 32 : 1000;
  1824.                 // Don't abort on the left mouse anymore!
  1825.                 gCapParms.fAbortLeftMouse = FALSE;
  1826.                 gCapParms.fAbortRightMouse = TRUE;
  1828.                 // If the Driver is Scrncap.drv, the following values are special
  1830.                 // If wChunkGranularity is zero, the granularity will be set to the
  1831.                 // disk sector size.
  1832.                 gCapParms.wChunkGranularity = (gbIsScrncap ? 32 : 0);
  1834.                 // Scrncap requires a callback for the message pump
  1835.                 capSetCallbackOnYield(ghWndCap, 
  1836.                         (gbIsScrncap ? fpYieldCallback : NULL));
  1838.                 // If the user has hit OK, set the new setup info
  1839.                 capCaptureSetSetup(ghWndCap, &gCapParms, sizeof(CAPTUREPARMS)) ;
  1840.             } else {
  1841.                 break;
  1842.             }
  1844.             // if no capture file, get that
  1845.             if (lstrlen(gachCaptureFile) <= 0) {
  1846.                 cmdSetCaptureFile(hWnd);
  1847.                 if (lstrlen(gachCaptureFile) <= 0) {
  1848.                     break;
  1849.                 }
  1850.             }
  1852.             // Capture video sequence
  1853.             fResult = capCaptureSequence(ghWndCap) ;
  1854.             break;
  1856.         case IDM_C_CAPTUREFRAME:
  1857.             // Turn off overlay / preview (gets turned off by frame capture)
  1858.             vidcapSetLive(FALSE);
  1859.             vidcapSetOverlay(FALSE);
  1861.             // Grab a frame
  1862.             fResult = capGrabFrameNoStop(ghWndCap) ;
  1863.             break;
  1866.         case IDM_C_CAPSEL:
  1867.             {
  1868.                 FARPROC fproc;
  1870.                 // if no capture file, get that
  1871.                 if (lstrlen(gachCaptureFile) <= 0) {
  1872.                     cmdSetCaptureFile(hWnd);
  1873.                     if (lstrlen(gachCaptureFile) <= 0) {
  1874.                         break;
  1875.                     }
  1876.                 }
  1878.                 fproc = MakeProcInstance(CapFramesProc, ghInstApp);
  1879.                 DialogBox(ghInstApp, MAKEINTRESOURCE(IDD_CAPFRAMES), hWnd, (DLGPROC) fproc);
  1880.                 FreeProcInstance(fproc);
  1881.             }
  1882.             break;
  1884. #ifdef DEBUG
  1885.         case IDM_C_TEST:
  1886.     nTestCount = 0;
  1887.     // Intentional fall through
  1888.     
  1889.         case IDM_C_TESTAGAIN:
  1890.             // set the defaults we won't bother the user with
  1891.             gCapParms.fMakeUserHitOKToCapture = FALSE;
  1892.             gCapParms.wPercentDropForError = 100;
  1894.             gCapParms.wNumVideoRequested = 
  1895.                     gCapParms.fUsingDOSMemory ? 32 : 1000;
  1897.             // Don't abort on the left mouse anymore!
  1898.             gCapParms.fAbortLeftMouse = FALSE;
  1899.             gCapParms.fAbortRightMouse = TRUE;
  1901.             // If wChunkGranularity is zero, the granularity will be set to the
  1902.             // disk sector size.
  1903.             gCapParms.wChunkGranularity = (gbIsScrncap ? 32 : 0);
  1905.             // If the user has hit OK, set the new setup info
  1906.             capCaptureSetSetup(ghWndCap, &gCapParms, sizeof(CAPTUREPARMS)) ;
  1908.             // if no capture file, get that
  1909.             if (lstrlen(gachCaptureFile) <= 0) {
  1910.                 cmdSetCaptureFile(hWnd);
  1911.                 if (lstrlen(gachCaptureFile) <= 0) {
  1912.                     break;
  1913.                 }
  1914.             }
  1915.     
  1916.     {
  1917. char buf[80];
  1919.                 gCapParms.wNumVideoRequested = 10;
  1920.                 gCapParms.wNumAudioRequested = 5;
  1921. gCapParms.fLimitEnabled = TRUE;
  1922. if (gCapParms.wTimeLimit == 0)
  1923.     gCapParms.wTimeLimit = 5;
  1924. capCaptureSetSetup(ghWndCap, &gCapParms, sizeof(CAPTUREPARMS)) ;
  1926. // Capture video sequence
  1927.                 fResult = capCaptureSequence(ghWndCap) ;
  1929. wsprintf (buf, "TestCount = %d", nTestCount++);
  1930. statusUpdateStatus(ghWndStatus, buf);
  1932. // Hold down the right mouse button to abort
  1933. if (!GetAsyncKeyState(VK_RBUTTON) & 0x0001)
  1934.     PostMessage (hWnd, WM_COMMAND, IDM_C_TESTAGAIN, 0L);
  1935.             }
  1936.             break;
  1937. #endif
  1938.     
  1939. /* --- help --- */
  1940.         case IDM_H_CONTENTS:
  1941.             HelpContents();
  1942.             break;
  1944.         case IDM_H_ABOUT:
  1945.             ShellAbout(
  1946.                 hWnd,
  1947.                 "VidCap",
  1948.                 "Video Capture Tool",
  1949.                 LoadIcon(ghInstApp,  gachIconName)
  1950.             );
  1951.             //DoDialog(hWnd, IDD_HelpAboutBox, AboutProc, 0);
  1952.             break ;
  1955.     }
  1957.     return 0L ;
  1958. }
  1960. /* --- menu help and enable/disable handling ------------------------ */
  1962. // write or clear status line help text when the user brings up or cancels a
  1963. // menu. This depends on there being strings in the string table with
  1964. // the same ID as the corresponding menu item.
  1965. // Help text for the items along the menu bar (File, Edit etc) depends
  1966. // on IDM_FILE, IDM_EDIT being defined with values 100 apart in the same
  1967. // order as their index in the menu
  1968. void
  1969. MenuSelect(HWND hwnd, UINT cmd, UINT flags, HMENU hmenu)
  1970. {
  1971.     if ((LOWORD(flags) == 0xffff) && (hmenu == NULL)) {
  1972.         //menu closing - remove message
  1973.         statusUpdateStatus(ghWndStatus, NULL);
  1974.     } else if ( (flags & (MF_SYSMENU|MF_POPUP)) == (MF_SYSMENU|MF_POPUP)) {
  1975.         // the system menu itself
  1976.         statusUpdateStatus(ghWndStatus, MAKEINTRESOURCE(IDM_SYSMENU));
  1977.     } else if ((flags & MF_POPUP) == 0) {
  1978.         // a menu command item
  1979.         statusUpdateStatus(ghWndStatus, MAKEINTRESOURCE(cmd));
  1980.     } else {
  1981.         //a popup menu - we need to search to find which one.
  1982.         // note that the cmd item in Win16 will now have a
  1983.         // menu handle, whereas in Win32 it has an index.
  1984.         // NOTE: this code assumes that the menu items
  1985.         // are #defined 100 apart in the same order, starting
  1986.         // with IDM_FILE
  1987. #ifdef _WIN32
  1988.         statusUpdateStatus(ghWndStatus, MAKEINTRESOURCE(IDM_FILE + (cmd * 100)));
  1989. #else
  1990.         int i,c;
  1991.         HMENU hmenuMain; 
  1993.         hmenuMain = GetMenu(hWnd);
  1994.         c = GetMenuItemCount(hmenuMain);
  1996.         for(i = 0; i < c; i++) {
  1997.             if (hmenu == GetSubMenu(hmenuMain, i)) {
  1998.                 statusUpdateStatus(MAKEINTRESOURCE(IDM_FILE + (cmd*100)));
  1999.                 return(0);
  2000.             }
  2001.         }
  2002.         statusUpdateStatus(NULL);
  2003. #endif
  2004.     }
  2005. }
  2007. // a popup menu is being selected - enable or disable menu items
  2008. int
  2009. InitMenuPopup(
  2010.     HWND hwnd,
  2011.     HMENU hmenu,
  2012.     int index
  2013. )
  2014. {
  2015.     int i = MF_ENABLED;
  2016.     CAPSTATUS cs;
  2017.     BOOL bUsesPalettes;
  2019.     capGetStatus(ghWndCap, &cs, sizeof(cs));
  2021.     // try to see if the driver uses palettes
  2022.     if ((cs.hPalCurrent != NULL) || (cs.fUsingDefaultPalette)) {
  2023.         bUsesPalettes = TRUE;
  2024.     } else {
  2025.         bUsesPalettes = FALSE;
  2026.     }
  2029.     switch(index) {
  2030.     case 0:         // IDM_FILE
  2032.         if (lstrlen(gachCaptureFile) <= 0) {
  2033.             i = MF_GRAYED;
  2034.         }
  2035.         // save as enabled only if we have a capture file
  2036.         EnableMenuItem(hmenu, IDM_F_SAVEVIDEOAS, i);
  2037.         // edit video possible only if we have a capture file AND we've
  2038.         // captured something
  2039.         EnableMenuItem(hmenu, IDM_F_EDITVIDEO,
  2040.             (cs.dwCurrentVideoFrame > 0) ? i : MF_GRAYED);
  2042.         // allow save palette if there is one
  2043.         EnableMenuItem(hmenu, IDM_F_SAVEPALETTE,
  2044.             (cs.hPalCurrent != NULL) ? MF_ENABLED:MF_GRAYED);
  2046.         // allow load palette if the driver uses palettes
  2047.         EnableMenuItem(hmenu, IDM_F_LOADPALETTE,
  2048.             bUsesPalettes ? MF_ENABLED : MF_GRAYED);
  2050.         break;
  2052.     case 1:         // IDM_EDIT
  2054.         // paste palettes if driver uses them and there is one pastable
  2055.         EnableMenuItem(hmenu, IDM_E_PASTEPALETTE,
  2056.             (bUsesPalettes && IsClipboardFormatAvailable(CF_PALETTE)) ? MF_ENABLED:MF_GRAYED);
  2058.         break;
  2060.     case 2:         // IDM_OPTIONS
  2062.         EnableMenuItem(hmenu, IDM_O_AUDIOFORMAT,
  2063.             cs.fAudioHardware ? MF_ENABLED : MF_GRAYED);
  2065.         EnableMenuItem(hmenu, IDM_O_OVERLAY,
  2066.             gCapDriverCaps.fHasOverlay ? MF_ENABLED:MF_GRAYED);
  2068.         EnableMenuItem(hmenu, IDM_O_VIDEOFORMAT,
  2069.             gCapDriverCaps.fHasDlgVideoFormat ? MF_ENABLED:MF_GRAYED);
  2071.         EnableMenuItem(hmenu, IDM_O_VIDEODISPLAY,
  2072.             gCapDriverCaps.fHasDlgVideoDisplay ? MF_ENABLED:MF_GRAYED);
  2074.         EnableMenuItem(hmenu, IDM_O_VIDEOSOURCE,
  2075.             gCapDriverCaps.fHasDlgVideoSource ? MF_ENABLED:MF_GRAYED);
  2077.         EnableMenuItem(hmenu, IDM_O_PREVIEW,
  2078.                 gbHaveHardware ? MF_ENABLED:MF_GRAYED);
  2081.     case 3:     // IDM_CAPTURE
  2082.         if (!gbHaveHardware) {
  2083.             i = MF_GRAYED;
  2084.         }
  2085.         EnableMenuItem(hmenu, IDM_C_CAPSEL, i);
  2086.         EnableMenuItem(hmenu, IDM_C_CAPTUREFRAME, i);
  2087.         EnableMenuItem(hmenu, IDM_C_CAPTUREVIDEO, i);
  2088.         EnableMenuItem(hmenu, IDM_C_PALETTE, (gbHaveHardware &&
  2089.             gCapDriverCaps.fDriverSuppliesPalettes) ? MF_ENABLED : MF_GRAYED);
  2091.         break;
  2092.     }
  2093.     return(0);
  2094. }
  2099. //
  2100. // MainWndProc: Application Main Window Procedure
  2101. //
  2102. LONG FAR PASCAL MainWndProc(HWND hWnd, UINT Message, UINT wParam, LONG lParam)
  2103. {
  2104. ////////////////////////////////////////////////////////////////////////
  2105. //  hWnd:      Application main window handle
  2106. //  Message:   Next message to be processed
  2107. //  wParam:    WORD param for the message
  2108. //  lParam:    LONG param for the message
  2109. ////////////////////////////////////////////////////////////////////////
  2111.     switch (Message) {
  2113.         static BOOL fMinimized;
  2115.         case WM_SYSCOMMAND:
  2116.     if ((wParam & 0xfff0) == SC_MAXIMIZE)
  2117.      fMinimized = FALSE;
  2118.     else if ((wParam & 0xfff0) == SC_RESTORE)
  2119.      fMinimized = FALSE;
  2120.     else if ((wParam & 0xfff0) == SC_MINIMIZE)
  2121.      fMinimized = TRUE;
  2122.     return DefWindowProc(hWnd, Message, wParam, lParam);
  2123.     break;
  2125.         case WM_COMMAND:
  2126.             MenuProc(hWnd, wParam, lParam) ;
  2127.             break ;
  2129.         case WM_CREATE:
  2130.             HelpInit(ghInstApp, "vidcap.hlp", hWnd);
  2131.             break;
  2133.         case WM_NCHITTEST:
  2134.         {
  2135.             DWORD dw;
  2137.             dw = DefWindowProc(hWnd, Message, wParam, lParam);
  2138.             // Don't allow border resize if autosizing
  2139.             if (gbAutoSizeFrame) {
  2140.                 if (dw >= HTSIZEFIRST && dw <= HTSIZELAST)
  2141.                     dw = HTCAPTION;
  2142.             }
  2143.             return dw;
  2144.                 
  2145.         }
  2146.             break;
  2148.         case WM_GETMINMAXINFO:
  2149.             // Don't allow manual sizing if window locked to the capture size
  2150.             if (gbHaveHardware && gbAutoSizeFrame && !gbInLayout) {
  2151.                 RECT rW;
  2153.                 LPMINMAXINFO lpMMI = (LPMINMAXINFO) lParam;
  2155.                 GetWindowRect (hWnd, &rW);
  2156.                 lpMMI->ptMinTrackSize.x = rW.right - rW.left;
  2157.                 lpMMI->ptMinTrackSize.y = rW.bottom - rW.top;
  2158.                 lpMMI->ptMaxTrackSize = lpMMI->ptMinTrackSize;
  2159.             }
  2160.             break;
  2162.         case WM_MOVE:
  2163.     if (!fMinimized) {
  2164.      vidcapLayout (hWnd);
  2165.     }
  2166.     break;
  2168.         case WM_SIZE:
  2169.     if (!fMinimized) {
  2170.      vidcapLayout (hWnd);
  2171.     }
  2172.     break;
  2174.         case WM_MENUSELECT:
  2175.             {
  2176.                 UINT cmd = GET_WM_MENUSELECT_CMD(wParam, lParam);
  2177.                 UINT flags = GET_WM_MENUSELECT_FLAGS(wParam, lParam);
  2178.                 HMENU hmenu = GET_WM_MENUSELECT_HMENU(wParam, lParam);
  2180.                 MenuSelect(hWnd, cmd, flags, hmenu);
  2181.             }
  2182.             break;
  2184.         case WM_INITMENUPOPUP:
  2185.             {
  2186.                 BOOL bSystem = (BOOL) HIWORD(lParam);
  2188.                 if (!bSystem) {
  2189.                     return InitMenuPopup(hWnd,
  2190.                             (HMENU) wParam, (int) LOWORD(lParam));
  2191.                 } else {
  2192.                     return(DefWindowProc(hWnd, Message, wParam, lParam));
  2193.                 }
  2194.             }
  2197.         case WM_SYSCOLORCHANGE:
  2198.             // we don't use this ourselves, but we should pass
  2199.             // it on to all three children
  2200.             SendMessage(ghWndFrame, Message, wParam, lParam);
  2201.             SendMessage(ghWndToolBar, Message, wParam, lParam);
  2202.             SendMessage(ghWndStatus, Message, wParam, lParam);
  2203.             return (TRUE);
  2206.         case WM_PALETTECHANGED:
  2207.         case WM_QUERYNEWPALETTE:
  2208.             // Pass the buck to Capture window proc
  2209.             return SendMessage(ghWndCap, Message, wParam, lParam) ;
  2210.             break ;
  2212.         case WM_SETFOCUS:
  2213.             // the toolbar is the only part that needs the focus
  2214.             SetFocus(ghWndToolBar);
  2215.             break;
  2218.         case WM_ACTIVATEAPP:
  2219.             if (wParam && ghWndCap) 
  2220.                 capPreviewRate(ghWndCap, 15); // Fast preview when active
  2221.             else
  2222.                 capPreviewRate(ghWndCap, 1000); // Slow preview when inactive
  2223.             break;
  2225.         case WM_NEXTDLGCTL:
  2226.             // if anyone is tabbing about, move the focus to the
  2227.             // toolbar
  2228.             SetFocus(ghWndToolBar);
  2230.             // select the correct button to handle moving off one
  2231.             // end and back on the other end
  2232.             if (lParam == FALSE) {
  2233.                 // are we moving forwards or backwards ?
  2234.                 if (wParam == 0) {
  2235.                     // move to next - so select first button
  2236.                     toolbarSetFocus(ghWndToolBar, TB_FIRST);
  2237.                 } else {
  2238.                     // move to previous - so select last
  2239.                     toolbarSetFocus(ghWndToolBar, TB_LAST);
  2240.                 }
  2241.             }
  2242.             break;
  2244.         case WM_PAINT:
  2245.         {
  2246.             HDC           hDC ;
  2247.             PAINTSTRUCT   ps ;
  2249.             hDC = BeginPaint(hWnd, &ps) ;
  2251.             // Included in case the background is not a pure color
  2252.             SetBkMode(hDC, TRANSPARENT) ;
  2254.             EndPaint(hWnd, &ps) ;
  2255.             break ;
  2256.         }
  2258.         case WM_CLOSE:
  2259.             // Disable and free all the callbacks 
  2260.             capSetCallbackOnError(ghWndCap, NULL) ;
  2261. if (fpErrorCallback) {
  2262.              FreeProcInstance(fpErrorCallback) ;
  2263. fpErrorCallback = NULL;
  2264. }
  2266.             capSetCallbackOnStatus(ghWndCap, NULL) ;
  2267. if (fpStatusCallback) {
  2268.              FreeProcInstance(fpStatusCallback) ;
  2269. fpStatusCallback = NULL;
  2270. }
  2272.             capSetCallbackOnYield(ghWndCap, NULL) ;
  2273. if (fpYieldCallback) {
  2274.              FreeProcInstance(fpYieldCallback) ;
  2275. fpYieldCallback = NULL;
  2276. }
  2278.             // Disconnect the current capture driver
  2279.             capDriverDisconnect (ghWndCap);
  2281.             // Destroy child windows, modeless dialogs, then this window...
  2282.             // DestroyWindow(ghWndCap) ;
  2283.             DestroyWindow(hWnd) ;
  2284.             break ;
  2286.         case WM_DESTROY:
  2287.             {
  2288.                 // remember window size and position
  2289.                 // - this will be written to the profile
  2290.                 WINDOWPLACEMENT wp;
  2292.                 wp.length = sizeof (WINDOWPLACEMENT);
  2293.                 GetWindowPlacement(hWnd, &wp);
  2295.                 gWinShow = wp.showCmd;
  2296.                 gWinX = wp.rcNormalPosition.left;
  2297.                 gWinY = wp.rcNormalPosition.top;
  2298.                 gWinCX = RECTWIDTH(wp.rcNormalPosition);
  2299.                 gWinCY = RECTHEIGHT(wp.rcNormalPosition);
  2301.                 // write defaults out to the registry
  2302.                 vidcapWriteProfile();
  2303.                 vidcapWriteSettingsProfile();
  2305.                 HelpShutdown();
  2307.             }
  2309.             PostQuitMessage(0) ;
  2310.             break ;
  2312.         default:
  2313.             return DefWindowProc(hWnd, Message, wParam, lParam) ;
  2314.     }
  2316.     return 0L;
  2317. }   // End of MainWndProc