Advanced Capture Application for C

#define MAKE_MEDIA_PATH(pFileName) (TEXT("C:\\Program Files (x86)\\LEAD Technologies\\LEADTOOLS 19\\Media\\")TEXT(pFileName)) 
// define helper macros for using interfaces under C 
#ifndef COBJMACROS 
#define COBJMACROS 
#endif 
#define UNUSED_PARAMETER(x) (void) (x) 
// include the LEAD Multimedia TOOLKIT header 
#include "ltmm.h" 
#include "resource.h" 
#include <tchar.h> 
#include <stdio.h> 
#include <olectl.h> 
#include <math.h> 
#include <assert.h> 
#define SZ_WNDCLASS_CAPTURE _T("CAPTURE WNDCLASS") 
#define WM_CAPTURENOTIFY (WM_USER + 1000) 
HINSTANCE g_hInstance;    // application instance handle 
HWND g_hwndCapture;      // video frame window 
IltmmCapture* g_pCapture;   // capture object interface pointer 
// 
// FreeTarget 
// resets target and free asssociated resources 
// 
void FreeTarget(void) 
{ 
   long type; 
   VARIANT var; 
   IltmmCapture_get_TargetType(g_pCapture, &type); 
   if(type == ltmmCapture_Target_Array) 
   { 
      IltmmCapture_get_TargetArray(g_pCapture, &var); 
      IltmmCapture_ResetTarget(g_pCapture); 
      VariantClear(&var); 
   } 
   else 
   { 
      IltmmCapture_ResetTarget (g_pCapture); 
   } 
} 
// 
// SnapFrameToVideo 
// resizes the frame window to match the video width and height 
// 
void SnapFrameToVideo(void) 
{ 
   HWND hwnd; 
   RECT rcWindow, rcClient; 
   long cx, cy; 
   // get the frame window 
   IltmmCapture_get_VideoWindowFrame(g_pCapture, (long*) &hwnd); 
   // get the video dimensions 
   IltmmCapture_get_VideoWidth(g_pCapture, &cx); 
   IltmmCapture_get_VideoHeight(g_pCapture, &cy); 
   // adjust by the border dimensions 
   GetWindowRect(hwnd, &rcWindow); 
   GetClientRect(hwnd, &rcClient); 
   cx += ((rcWindow.right - rcWindow.left) - (rcClient.right - rcClient.left)); 
   cy += ((rcWindow.bottom - rcWindow.top) - (rcClient.bottom - rcClient.top)); 
   // resize the window 
   SetWindowPos(hwnd, NULL, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER); 
} 
// 
// CaptureWndProc 
// video frame window procedure 
// 
LRESULT CALLBACK CaptureWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) 
{ 
   VARIANT_BOOL f; 
   HRESULT hr; 
   HGLOBAL hDIB; 
   IPictureDisp* pPictureDisp; 
   BSTR bstr; 
   IltmmDevices* pDevices; 
   IltmmTargetDevices* pTargetDevices; 
   long index; 
   IltmmCompressors* pCompressors; 
   long l; 
   long l2; 
   BOOL fActive; 
   ltmmSizeMode sm; 
   TCHAR sz[2048]; 
   LPTSTR p; 
   double d; 
   VARIANT var; 
   long x, y, cx, cy; 
   RECT rc; 
   POINT pt; 
   IltmmVCRControl* pVCR; 
   switch (message) 
   { 
   case WM_CREATE: 
      g_hwndCapture = hwnd; 
      // window is the video window frame 
      IltmmCapture_put_VideoWindowFrame(g_pCapture, (long) hwnd); 
      // want notification messages as well 
      IltmmCapture_SetNotifyWindow(g_pCapture, (long) hwnd, WM_CAPTURENOTIFY); 
      // set preview source video only 
      IltmmCapture_put_PreviewSource(g_pCapture, ltmmCapture_Preview_Video); 
      // enable preview 
      IltmmCapture_put_Preview(g_pCapture, VARIANT_TRUE); 
      // disable close captioning 
      IltmmCapture_put_CloseCaptioning(g_pCapture, VARIANT_FALSE); 
      // assign initial frame delay 
      IltmmCapture_put_FrameDelay(g_pCapture, 1.0); 
      // assign a target file 
      bstr = SysAllocString(MAKE_MEDIA_PATH("target.avi")); 
      IltmmCapture_put_TargetFile(g_pCapture, bstr); 
      SysFreeString(bstr); 
      // select the LEAD video compressor 
      IltmmCapture_get_VideoCompressors(g_pCapture, &pCompressors); 
      bstr = SysAllocString(L"@device:sw:{33D9A760-90C8-11D0-BD43-00A0C911CE86}\\LEAD MCMP/MJPEG Codec (2.0)"); 
      IltmmCompressors_Find(pCompressors, bstr, &index); 
      SysFreeString(bstr); 
      if(index >= 0) 
         IltmmCompressors_put_Selection(pCompressors, index); 
      IUnknown_Release(pCompressors); 
      // select the MP3 audio video compressor 
      IltmmCapture_get_AudioCompressors(g_pCapture, &pCompressors); 
      bstr = SysAllocString(L"@device:cm:{33D9A761-90C8-11D0-BD43-00A0C911CE86}\\85MPEG Layer-3"); 
      IltmmCompressors_Find(pCompressors, bstr, &index); 
      SysFreeString(bstr); 
      if(index >= 0) 
         IltmmCompressors_put_Selection(pCompressors, index); 
      IUnknown_Release(pCompressors); 
      // target format is AVI 
      IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_Avi); 
      // preallocate file to 10 MB 
      IltmmCapture_AllocTarget(g_pCapture, 10); 
      // select the first audio device available 
      IltmmCapture_get_AudioDevices(g_pCapture, &pDevices); 
      IltmmDevices_put_Selection(pDevices, 0); 
      IUnknown_Release(pDevices); 
      // select the first video device available 
      IltmmCapture_get_VideoDevices(g_pCapture, &pDevices); 
      IltmmDevices_put_Selection(pDevices, 0); 
      IUnknown_Release(pDevices); 
      SnapFrameToVideo(); 
      return 0; 
      break; 
   case WM_CAPTURENOTIFY: 
      switch(wParam) 
      { 
   case ltmmCapture_Notify_Started: 
         _stprintf(sz, _T("Started")); 
         SetWindowText(hwnd, sz); 
         break; 
   case ltmmCapture_Notify_Complete: 
         // stop recording, if vcr output 
         IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Stop(pVCR); 
         IUnknown_Release(pVCR); 
         IltmmCapture_get_Mode(g_pCapture, &l); 
         if(l == ltmmCapture_Mode_Still) 
         { 
            _stprintf(sz, _T("Complete - [still]")); 
         } 
         else 
         { 
            IltmmCapture_get_TargetType(g_pCapture, &l); 
            if(l == ltmmCapture_Target_Array) 
            { 
               _stprintf(sz, _T("Complete - [array]")); 
            } 
            else if(l == ltmmCapture_Target_Device) 
            { 
               _stprintf(sz, _T("Complete - [device]")); 
            } 
            else 
            { 
               IltmmCapture_get_TargetFile(g_pCapture, &bstr); 
               _stprintf(sz, _T("Complete - [%ls]"), bstr); 
               SysFreeString(bstr); 
            } 
         } 
         SetWindowText(hwnd, sz); 
         break; 
   case ltmmCapture_Notify_ErrorAbort: 
         // stop recording, if vcr output 
         IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Stop (pVCR); 
         IUnknown_Release(pVCR); 
         _stprintf(sz, _T("Error 0x%.8X. Capture stopped."), lParam); 
         MessageBox(hwnd, sz, _T("Play"), MB_ICONEXCLAMATION | MB_OK); 
         break; 
   case ltmmCapture_Notify_Progress: 
         p = sz; 
         *p = _T('\0'); 
         hr = IltmmCapture_get_NumDropped(g_pCapture, &l); 
         if(SUCCEEDED(hr)) 
         { 
            if(p != sz) 
               p += _stprintf(p, _T(", ")); 
            p += _stprintf(p, _T("Dropped: %d"), l); 
         } 
         hr = IltmmCapture_get_NumNotDropped(g_pCapture, &l); 
         if(SUCCEEDED(hr)) 
         { 
            if(p != sz) 
               p += _stprintf(p, _T(", ")); 
            p += _stprintf(p, _T("Not Dropped: %d"), l); 
         } 
         hr = IltmmCapture_get_AverageFrameSize(g_pCapture, &l); 
         if(SUCCEEDED(hr)) 
         { 
            if(p != sz) 
               p += _stprintf(p, _T(", ")); 
            p += _stprintf(p, _T("Frame Size: %d"), l); 
         } 
         IltmmCapture_get_Mode(g_pCapture, &l); 
         if(l != ltmmCapture_Mode_Still || l != ltmmCapture_Mode_ManualFrames) 
         { 
            // only display the capture time for free running captures 
            hr = IltmmCapture_get_CaptureTime(g_pCapture, &d); 
            if(SUCCEEDED(hr)) 
            { 
               if(p != sz) 
                  p += _stprintf(p, _T(", ")); 
               p += _stprintf(p, _T("Time: %f"), d); 
            } 
         } 
         SetWindowText(hwnd, sz); 
         break; 
      } 
      return 0; 
      break; 
   case WM_KEYDOWN: 
      if(wParam == VK_ESCAPE) 
      { 
         // if fullscreen mode then exit it 
         IltmmCapture_get_FullScreenMode(g_pCapture, &f); 
         if(f) 
         { 
            IltmmCapture_put_FullScreenMode(g_pCapture, VARIANT_FALSE); 
            return 0; 
         } 
      } 
      break; 
   case WM_DESTROY: 
      // no more notifications 
      FreeTarget(); 
      IltmmCapture_SetNotifyWindow(g_pCapture, (long) NULL, 0); 
      PostQuitMessage(0); 
      break; 
   case WM_INITMENUPOPUP: 
      if(GetSubMenu(GetMenu(hwnd), 0) == (HMENU)wParam) 
      { 
         // determine whether the object is active 
         IltmmCapture_get_State(g_pCapture, &l); 
         fActive = (l == ltmmCapture_State_Pending || l == ltmmCapture_State_Running || l == ltmmCapture_State_Paused); 
         // enable stop if active 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_STOPCAPTURE, fActive ? MF_ENABLED : MF_GRAYED); 
         // enable run if paused 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_RUN, (l == ltmmCapture_State_Paused) ? MF_ENABLED : MF_GRAYED); 
         // enable pause if running or pending 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_PAUSE, (l == ltmmCapture_State_Paused || l == ltmmCapture_State_Pending) ? MF_ENABLED : MF_GRAYED); 
         // determine if capture properties are available 
         IltmmCapture_HasDialog(g_pCapture, ltmmCapture_Dlg_Capture, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREPROPERTIES, (!fActive && f) ? MF_ENABLED : MF_GRAYED); 
         // can the control perform normal capture? 
         IltmmCapture_IsModeAvailable(g_pCapture, ltmmCapture_Mode_VideoOrAudio, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_STARTCAPTURE, f ? MF_ENABLED : MF_GRAYED); 
         // can the control perform auto frame capture? 
         IltmmCapture_IsModeAvailable(g_pCapture, ltmmCapture_Mode_AutoFrames, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREAUTOFRAMES, f ? MF_ENABLED : MF_GRAYED); 
         // can the control perform manual frame capture? 
         IltmmCapture_IsModeAvailable(g_pCapture, ltmmCapture_Mode_ManualFrames, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREMANUALFRAMES, f ? MF_ENABLED : MF_GRAYED); 
         // can the control perform still image capture? 
         IltmmCapture_IsModeAvailable(g_pCapture, ltmmCapture_Mode_Still, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREDIB, f ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREPICTURE, f ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_GETSTILLDIB, f ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_GETSTILLPICTURE, f ? MF_ENABLED : MF_GRAYED); 
         // check which video size mode is being used 
         IltmmCapture_get_VideoWindowSizeMode(g_pCapture, &sm); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FITTOWINDOW, (sm == ltmmFit) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_STRETCHTOWINDOW, (sm == ltmmStretch) ? MF_CHECKED : MF_UNCHECKED); 
         // check the preview status 
         IltmmCapture_get_Preview(g_pCapture, &f); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PREVIEW, f ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_PREVIEW, !fActive ? MF_ENABLED : MF_GRAYED); 
         // check the audio preview status 
         IltmmCapture_get_PreviewSource(g_pCapture, &l); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PREVIEWVIDEOANDAUDIO, (l == ltmmCapture_Preview_VideoAndAudio) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_PREVIEWVIDEOANDAUDIO, !fActive ? MF_ENABLED : MF_GRAYED); 
         // check close captioning 
         IltmmCapture_get_CloseCaptioning(g_pCapture, &f); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_CLOSECAPTIONING, f ? MF_CHECKED : MF_UNCHECKED); 
         IltmmCapture_get_CloseCaptionAvailable(g_pCapture, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CLOSECAPTIONING, (!fActive && f) ? MF_ENABLED : MF_GRAYED); 
         // check the master stream 
         IltmmCapture_get_MasterStream(g_pCapture, &l); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_MASTERSTREAM_NONE, (l == ltmmCapture_MasterStream_None) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_MASTERSTREAM_AUDIO, (l == ltmmCapture_MasterStream_Audio) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_MASTERSTREAM_VIDEO, (l == ltmmCapture_MasterStream_Video) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_MASTERSTREAM_NONE, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_MASTERSTREAM_AUDIO, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_MASTERSTREAM_VIDEO, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         // check the frame rate 
         IltmmCapture_get_UseFrameRate(g_pCapture, &f); 
         IltmmCapture_get_FrameRate(g_pCapture, &d); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FRAMERATE_DEFAULT, (!f) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FRAMERATE_15FPS, (f && fabs(d - 15.0) < 0.1) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FRAMERATE_30FPS, (f && fabs(d - 30.0) < 0.1) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_FRAMERATE_DEFAULT, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_FRAMERATE_15FPS, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_FRAMERATE_30FPS, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         // check the time limit 
         IltmmCapture_get_UseTimeLimit(g_pCapture, &f); 
         IltmmCapture_get_TimeLimit(g_pCapture, &d); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TIMELIMIT_NONE, (!f) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TIMELIMIT_15SEC, (f && fabs(d - 15.0) < 0.1) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TIMELIMIT_30SEC, (f && fabs(d - 30.0) < 0.1) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TIMELIMIT_NONE, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TIMELIMIT_15SEC, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TIMELIMIT_30SEC, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         // check the frame delay 
         IltmmCapture_get_FrameDelay(g_pCapture, &d); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FRAMEDELAY_1SEC, (fabs(d - 1.0) < 0.1) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FRAMEDELAY_5SEC, (fabs(d - 5.0) < 0.1) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_FRAMEDELAY_1SEC, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_FRAMEDELAY_5SEC, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         // check the target 
         IltmmCapture_get_TargetType(g_pCapture, &l); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGET_FILE, (l == ltmmCapture_Target_File) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGET_ARRAY, (l == ltmmCapture_Target_Array) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGET_DEVICE, (l == ltmmCapture_Target_Device) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGET_FILE, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGET_ARRAY, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGET_DEVICE, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         IltmmCapture_get_TargetFormat(g_pCapture, &l); 
         IltmmCapture_get_TargetType(g_pCapture, &l2); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_AVI, (l == ltmmCapture_TargetFormat_Avi) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_WAVE, (l == ltmmCapture_TargetFormat_WAVE) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_MPEG1AUDIO, (l == ltmmCapture_TargetFormat_MPEG1Audio) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_AVI, (!fActive && l2 != ltmmCapture_Target_Device) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_WAVE, (!fActive && l2 != ltmmCapture_Target_Device) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_MPEG1AUDIO, (!fActive && l2 != ltmmCapture_Target_Device) ? MF_ENABLED : MF_GRAYED); 
         // check the processor preview 
         IltmmCapture_get_PreviewTap(g_pCapture, &l); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PREVIEWPROCESSORS, (l == ltmmCapture_PreviewTap_Processors) ? MF_CHECKED : MF_UNCHECKED); 
         // check the properties preview 
         IltmmCapture_get_ShowDialogPreview(g_pCapture, &f); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PROPERTIESPREVIEW, (f) ? MF_CHECKED : MF_UNCHECKED); 
         // enable the vcr controls 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_get_DeviceType(pVCR, &l); 
         // if no tape is loaded, then disable vcr control 
         IltmmVCRControl_get_MediaType(pVCR, &l2); 
         if(l2 == ltmmVCRControl_MediaType_NotPresent) 
            l = ltmmVCRControl_DeviceType_NotPresent; 
         // get the current vcr mode 
         IltmmVCRControl_get_Mode(pVCR, &l2); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_PLAY, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_Play) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_STOP, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_Stop) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_PAUSE, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_Pause) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_REWIND, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_Rewind) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_FASTFORWARD, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_FastForward) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_STEPFORWARD, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_StepForward) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_STEPBACKWARD, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_StepBackward) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_FASTESTFORWARD, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_FastestForward) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_FASTESTREVERSE, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_FastestReverse) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_SLOWESTFORWARD, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_SlowestForward) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_SLOWESTREVERSE, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != ltmmVCRControl_Mode_SlowestReverse) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_RECORD, (l != ltmmVCRControl_DeviceType_NotPresent && l2 != ltmmVCRControl_Mode_Record) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_PAUSERECORDING, (l != ltmmVCRControl_DeviceType_NotPresent && l2 != ltmmVCRControl_Mode_PauseRecording) ? MF_ENABLED : MF_GRAYED); 
         IltmmVCRControl_ReadTimecode(pVCR, &l2); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_VCR_SEEKSTART, (l != ltmmVCRControl_DeviceType_NotPresent  && l != ltmmVCRControl_DeviceType_Camera && l2 != 0) ? MF_ENABLED : MF_GRAYED); 
         IUnknown_Release(pVCR); 
         // check the audio buffer size 
         IltmmCapture_get_AudioBufferSize(g_pCapture, &d); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_AUDIOBUFFERING_05SECONDS, (fabs(d - 0.5) < 0.01) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_AUDIOBUFFERING_005SECONDS, (fabs(d - 0.05) < 0.01) ? MF_CHECKED : MF_UNCHECKED); 
      } 
      break; 
   case WM_COMMAND: 
      switch(LOWORD(wParam)) 
      { 
   case ID_CONTROL_FITTOWINDOW: 
         // fit the video to the window 
         IltmmCapture_put_VideoWindowSizeMode(g_pCapture, ltmmFit); 
         return 0; 
         break; 
   case ID_CONTROL_STRETCHTOWINDOW: 
         // stretch the video to the window 
         IltmmCapture_put_VideoWindowSizeMode(g_pCapture, ltmmStretch); 
         return 0; 
         break; 
   case ID_CONTROL_FULLSCREEN: 
         // toggle fullscreen mode 
         IltmmCapture_ToggleFullScreenMode(g_pCapture); 
         return 0; 
         break; 
   case ID_CONTROL_PREVIEW: 
         // toggle preview 
         IltmmCapture_TogglePreview(g_pCapture); 
         return 0; 
         break; 
   case ID_CONTROL_PREVIEWVIDEOANDAUDIO: 
         // toggle audio preview 
         IltmmCapture_get_PreviewSource(g_pCapture, &l); 
         if(l == ltmmCapture_Preview_VideoAndAudio) 
            IltmmCapture_put_PreviewSource(g_pCapture, ltmmCapture_Preview_Video); 
         else 
            IltmmCapture_put_PreviewSource(g_pCapture, ltmmCapture_Preview_VideoAndAudio); 
         return 0; 
         break; 
   case ID_CONTROL_CLOSECAPTIONING: 
         // toggle close captioning 
         IltmmCapture_ToggleCloseCaptioning(g_pCapture); 
         return 0; 
         break; 
   case ID_CONTROL_STOPCAPTURE: 
         // stop capturing 
         IltmmCapture_StopCapture(g_pCapture); 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREPROPERTIES: 
         // set the capture properties 
         IltmmCapture_ShowDialog(g_pCapture, ltmmCapture_Dlg_Capture, (long) hwnd); 
         return 0; 
         break; 
   case ID_CONTROL_STARTCAPTURE: 
         // ready capture to eliminate start delays 
         hr = IltmmCapture_ReadyCapture(g_pCapture, ltmmCapture_Mode_VideoOrAudio); 
         if(SUCCEEDED(hr)) 
         { 
            // start recording, if vcr output 
            IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
            hr = IltmmVCRControl_Record(pVCR); 
            IUnknown_Release(pVCR); 
            // uncomment the following line to view the the graph in DirectShow GraphEdit 
            // IltmmCapture_EditGraph(g_pCapture); 
            if(MessageBox(hwnd, _T("Ready to capture. Click 'ok' to start."), _T("Capture"), MB_OKCANCEL) == IDOK) 
            { 
               // start capturing 
               IltmmCapture_StartCapture(g_pCapture, ltmmCapture_Mode_VideoOrAudio); 
            } 
            else 
            { 
               // cancel capture 
               IltmmCapture_StopCapture(g_pCapture); 
               // stop recording, if vcr output 
               IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
               IltmmVCRControl_Stop (pVCR); 
               IUnknown_Release(pVCR); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_RUN: 
         // run the capture graph 
         IltmmCapture_RunCapture(g_pCapture); 
         return 0; 
         break; 
   case ID_CONTROL_PAUSE: 
         // pause the capture graph 
         IltmmCapture_PauseCapture(g_pCapture); 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREAUTOFRAMES: 
         hr = IltmmCapture_ReadyCapture(g_pCapture, ltmmCapture_Mode_AutoFrames); 
         if(SUCCEEDED(hr)) 
         { 
            // start recording, if vcr output 
            IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
            hr = IltmmVCRControl_Record(pVCR); 
            IUnknown_Release(pVCR); 
            if(SUCCEEDED(hr)) 
               Sleep(2000); 
            // start capturing the automatic frame sequence 
            IltmmCapture_StartCapture(g_pCapture, ltmmCapture_Mode_AutoFrames); 
         } 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREMANUALFRAMES: 
         hr = IltmmCapture_ReadyCapture(g_pCapture, ltmmCapture_Mode_ManualFrames); 
         if(SUCCEEDED(hr)) 
         { 
            // start recording, if vcr output 
            IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
            hr = IltmmVCRControl_Record(pVCR); 
            IUnknown_Release(pVCR); 
            if(SUCCEEDED(hr)) 
               Sleep(2000); 
            // start capturing the automatic frame sequence 
            hr = IltmmCapture_StartCapture(g_pCapture, ltmmCapture_Mode_ManualFrames); 
            if(SUCCEEDED(hr)) 
            { 
               while(MessageBox(hwnd, _T("Press 'ok' to capture frame."), _T("Capture Manual Frames"), MB_OKCANCEL) == IDOK) 
               IltmmCapture_CaptureFrame(g_pCapture); 
               IltmmCapture_StopCapture(g_pCapture); 
            } 
            // stop recording, if vcr output 
            IltmmCapture_get_TargetVCRControl(g_pCapture, &pVCR); 
            IltmmVCRControl_Stop(pVCR); 
            IUnknown_Release(pVCR); 
         } 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREDIB: 
         // capture device independent bitmap 
         hr = IltmmCapture_CaptureDIB(g_pCapture, (long*) &hDIB); 
         if(SUCCEEDED(hr)) 
         { 
            // copy to the clipboard 
            OpenClipboard(hwnd); 
            EmptyClipboard(); 
            SetClipboardData(CF_DIB, hDIB); 
            CloseClipboard(); 
         } 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREPICTURE: 
         // capture an ole picture object 
         hr = IltmmCapture_CapturePicture(g_pCapture, &pPictureDisp); 
         if(SUCCEEDED(hr)) 
         { 
            // save the picture 
            bstr = SysAllocString(MAKE_MEDIA_PATH("still.bmp")); 
            OleSavePictureFile((IDispatch*) pPictureDisp, bstr); 
            SysFreeString(bstr); 
            IUnknown_Release(pPictureDisp); 
         } 
         return 0; 
         break; 
   case ID_CONTROL_GETSTILLDIB: 
         // alternate method of capturing a device independent bitmap 
         hr = IltmmCapture_StartCapture(g_pCapture, ltmmCapture_Mode_Still); 
         if(SUCCEEDED(hr)) 
         { 
            hr = IltmmCapture_GetStillDIB(g_pCapture, INFINITE, (long*) &hDIB); 
            IltmmCapture_StopCapture(g_pCapture); 
            if(SUCCEEDED(hr)) 
            { 
               // copy to the clipboard 
               OpenClipboard(hwnd); 
               EmptyClipboard(); 
               SetClipboardData(CF_DIB, hDIB); 
               CloseClipboard(); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_GETSTILLPICTURE: 
         // alternate method for capturing an ole picture object 
         hr = IltmmCapture_StartCapture(g_pCapture, ltmmCapture_Mode_Still); 
         if(SUCCEEDED(hr)) 
         { 
            hr = IltmmCapture_GetStillPicture(g_pCapture, INFINITE, &pPictureDisp); 
            IltmmCapture_StopCapture(g_pCapture); 
            if(SUCCEEDED(hr)) 
            { 
               // save the picture 
               bstr = SysAllocString(MAKE_MEDIA_PATH("still.bmp")); 
               OleSavePictureFile((IDispatch*) pPictureDisp, bstr); 
               SysFreeString(bstr); 
               IUnknown_Release(pPictureDisp); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_COPYTARGET: 
         // copy the target file 
         bstr = SysAllocString(MAKE_MEDIA_PATH("targetcopy.avi")); 
         IltmmCapture_CopyTarget(g_pCapture, bstr, VARIANT_FALSE); 
         SysFreeString(bstr); 
         return 0; 
         break; 
   case ID_CONTROL_MASTERSTREAM_NONE: 
         // no master stream 
         IltmmCapture_put_MasterStream(g_pCapture, ltmmCapture_MasterStream_None); 
         return 0; 
         break; 
   case ID_CONTROL_MASTERSTREAM_AUDIO: 
         // set the audio master 
         IltmmCapture_put_MasterStream(g_pCapture, ltmmCapture_MasterStream_Audio); 
         return 0; 
         break; 
   case ID_CONTROL_MASTERSTREAM_VIDEO: 
         // set the video master 
         IltmmCapture_put_MasterStream(g_pCapture, ltmmCapture_MasterStream_Video); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMERATE_DEFAULT: 
         // set the rate to default 
         IltmmCapture_put_UseFrameRate(g_pCapture, VARIANT_FALSE); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMERATE_15FPS: 
         // set the rate to 15 fps 
         IltmmCapture_put_FrameRate(g_pCapture, 15.0); 
         IltmmCapture_put_UseFrameRate(g_pCapture, VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMERATE_30FPS: 
         // set rate to 30 fps 
         IltmmCapture_put_FrameRate(g_pCapture, 30.0); 
         IltmmCapture_put_UseFrameRate(g_pCapture, VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_TIMELIMIT_NONE: 
         // no time limit 
         IltmmCapture_put_UseTimeLimit(g_pCapture, VARIANT_FALSE); 
         return 0; 
         break; 
   case ID_CONTROL_TIMELIMIT_15SEC: 
         // 15 sec time limit 
         IltmmCapture_put_TimeLimit(g_pCapture, 15.0); 
         IltmmCapture_put_UseTimeLimit(g_pCapture, VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_TIMELIMIT_30SEC: 
         // 30 sec time limit 
         IltmmCapture_put_TimeLimit(g_pCapture, 30.0); 
         IltmmCapture_put_UseTimeLimit(g_pCapture, VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMEDELAY_1SEC: 
         // 1 sec frame delay 
         IltmmCapture_put_FrameDelay(g_pCapture, 1.0); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMEDELAY_5SEC: 
         // 5 sec frame delay 
         IltmmCapture_put_FrameDelay(g_pCapture, 5.0); 
         return 0; 
         break; 
   case ID_CONTROL_TARGET_FILE: 
         // assign a target file 
         FreeTarget(); 
         // select the LEAD video compressor 
         IltmmCapture_get_VideoCompressors(g_pCapture, &pCompressors); 
         bstr = SysAllocString(L"@device:sw:{33D9A760-90C8-11D0-BD43-00A0C911CE86}\\LEAD MCMP/MJPEG Codec (2.0)"); 
         IltmmCompressors_Find(pCompressors, bstr, &index); 
         SysFreeString(bstr); 
         if(index >= 0) 
            IltmmCompressors_put_Selection(pCompressors, index); 
         IUnknown_Release(pCompressors); 
         // select the MP3 audio video compressor 
         IltmmCapture_get_AudioCompressors(g_pCapture, &pCompressors); 
         bstr = SysAllocString(L"@device:cm:{33D9A761-90C8-11D0-BD43-00A0C911CE86}\\85MPEG Layer-3"); 
         IltmmCompressors_Find(pCompressors, bstr, &index); 
         SysFreeString(bstr); 
         if(index >= 0) 
            IltmmCompressors_put_Selection(pCompressors, index); 
         IUnknown_Release(pCompressors); 
         IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_Avi); 
         bstr = SysAllocString(MAKE_MEDIA_PATH("target.avi")); 
         IltmmCapture_put_TargetFile(g_pCapture, bstr); 
         SysFreeString(bstr); 
         return 0; 
         break; 
   case ID_CONTROL_TARGET_ARRAY: 
         // assign a target array 
         FreeTarget(); 
         // select the LEAD video compressor 
         IltmmCapture_get_VideoCompressors(g_pCapture, &pCompressors); 
         bstr = SysAllocString(L"@device:sw:{33D9A760-90C8-11D0-BD43-00A0C911CE86}\\LEAD MCMP/MJPEG Codec (2.0)");         IltmmCompressors_Find(pCompressors, bstr, &index); 
         SysFreeString(bstr); 
         if(index >= 0) 
            IltmmCompressors_put_Selection(pCompressors, index); 
         IUnknown_Release(pCompressors); 
         // select the MP3 audio video compressor 
         IltmmCapture_get_AudioCompressors(g_pCapture, &pCompressors); 
         bstr = SysAllocString(L"@device:cm:{33D9A761-90C8-11D0-BD43-00A0C911CE86}\\85MPEG Layer-3"); 
         IltmmCompressors_Find(pCompressors, bstr, &index); 
         SysFreeString(bstr); 
         if(index >= 0) 
            IltmmCompressors_put_Selection(pCompressors, index); 
         IUnknown_Release(pCompressors); 
         IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_Avi); 
         VariantInit(&var); 
         V_VT(&var) = (VT_ARRAY | VT_UI1); 
         V_ARRAY(&var) = SafeArrayCreateVector(VT_UI1, 0, 0); 
         IltmmCapture_put_TargetArray(g_pCapture, var); 
         return 0; 
         break; 
   case ID_CONTROL_TARGET_DEVICE: 
         // assign a target device 
         FreeTarget(); 
         // deselect the video compressor 
         IltmmCapture_get_VideoCompressors(g_pCapture, &pCompressors); 
         IltmmCompressors_put_Selection(pCompressors, -1); 
         IUnknown_Release(pCompressors); 
         // deselect the audio compressor 
         IltmmCapture_get_AudioCompressors(g_pCapture, &pCompressors); 
         IltmmCompressors_put_Selection(pCompressors, -1); 
         IUnknown_Release(pCompressors); 
         IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_dvsd); 
         // select the first output device 
         IltmmCapture_get_TargetDevices(g_pCapture, &pTargetDevices); 
         IltmmTargetDevices_put_Selection(pTargetDevices, 0); 
         IUnknown_Release(pTargetDevices); 
         return 0; 
         break; 
   case ID_CONTROL_TARGETFORMAT_AVI: 
         // is the target a file? 
         IltmmCapture_get_TargetType(g_pCapture, &l); 
         if(l == ltmmCapture_Target_File) 
         { 
            // rename it 
            bstr = SysAllocString(MAKE_MEDIA_PATH("target.avi")); 
            IltmmCapture_put_TargetFile(g_pCapture, bstr); 
            SysFreeString(bstr); 
         } 
         IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_Avi); 
         return 0; 
         break; 
   case ID_CONTROL_TARGETFORMAT_WAVE: 
         // is the target a file? 
         IltmmCapture_get_TargetType(g_pCapture, &l); 
         if(l == ltmmCapture_Target_File) 
         { 
            // rename it 
            bstr = SysAllocString(MAKE_MEDIA_PATH("target.wav")); 
            IltmmCapture_put_TargetFile(g_pCapture, bstr); 
            SysFreeString(bstr); 
         } 
         IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_WAVE); 
         return 0; 
         break; 
   case ID_CONTROL_TARGETFORMAT_MPEG1AUDIO: 
         // is the target a file? 
         IltmmCapture_get_TargetType(g_pCapture, &l); 
         if(l == ltmmCapture_Target_File) 
         { 
            // rename it 
            bstr = SysAllocString(MAKE_MEDIA_PATH("target.mp3")); 
            IltmmCapture_put_TargetFile(g_pCapture, bstr); 
            SysFreeString(bstr); 
         } 
         // we have already selected the MP3 compressor 
         IltmmCapture_put_TargetFormat(g_pCapture, ltmmCapture_TargetFormat_MPEG1Audio); 
         return 0; 
         break; 
   case ID_CONTROL_AUDIOPROCESSORS: 
         // edit the audio processors 
         IltmmCapture_ShowDialog(g_pCapture, ltmmCapture_Dlg_AudioProcessors, (long) hwnd); 
         return 0; 
         break; 
   case ID_CONTROL_VIDEOPROCESSORS: 
         // edit the video processors 
         IltmmCapture_ShowDialog(g_pCapture, ltmmCapture_Dlg_VideoProcessors, (long) hwnd); 
         return 0; 
         break; 
   case ID_CONTROL_PREVIEWPROCESSORS: 
         // toggle the processor preview 
         IltmmCapture_get_PreviewTap(g_pCapture, &l); 
         IltmmCapture_put_PreviewTap(g_pCapture, (l == ltmmCapture_PreviewTap_Processors) ? ltmmCapture_PreviewTap_Source : ltmmCapture_PreviewTap_Processors); 
         return 0; 
         break; 
   case ID_CONTROL_PROPERTIESPREVIEW: 
         // toggle the preview while editing properties 
         IltmmCapture_get_ShowDialogPreview(g_pCapture, &f); 
         IltmmCapture_put_ShowDialogPreview(g_pCapture, f ? VARIANT_FALSE : VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_PLAY: 
         // vcr play 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Play(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_STOP: 
         // vcr stop 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Stop (pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_PAUSE: 
         // vcr pause 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Pause(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_FASTFORWARD: 
         // vcr fast forward 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_FastForward(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_REWIND: 
         // vcr rewind 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Rewind(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_RECORD: 
         // vcr record 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_Record(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_PAUSERECORDING: 
         // vcr pause recording 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_PauseRecording(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_STEPFORWARD: 
         // vcr step forward 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_StepForward(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_STEPBACKWARD: 
         // vcr step backward 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_StepBackward(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_FASTESTFORWARD: 
         // vcr fastest forward 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_FastestForward(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_FASTESTREVERSE: 
         // vcr fastest reverse 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_FastestReverse(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_SLOWESTFORWARD: 
         // vcr slowest forward 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_SlowestForward(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_SLOWESTREVERSE: 
         // vcr slowest reverse 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_SlowestReverse(pVCR); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_VCR_SEEKSTART: 
         // vcr seek start 
         IltmmCapture_get_CaptureVCRControl(g_pCapture, &pVCR); 
         IltmmVCRControl_SeekTimecode(pVCR, 0); 
         IUnknown_Release(pVCR); 
         return 0; 
         break; 
   case ID_CONTROL_AUDIOBUFFERING_05SECONDS: 
         // set 0.5 second audio buffer 
         IltmmCapture_put_AudioBufferSize(g_pCapture, 0.5); 
         return 0; 
         break; 
   case ID_CONTROL_AUDIOBUFFERING_005SECONDS: 
         // set 0.05 second audio buffer 
         IltmmCapture_put_AudioBufferSize(g_pCapture, 0.05); 
         return 0; 
         break; 
      } 
      break; 
   case WM_LBUTTONDOWN: 
      IltmmCapture_get_State(g_pCapture, &l); 
      if(l != ltmmCapture_State_Pending || l != ltmmCapture_State_Running) 
      { 
         IltmmCapture_get_VideoWindowLeft(g_pCapture, &x); 
         IltmmCapture_get_VideoWindowTop(g_pCapture, &y); 
         IltmmCapture_get_VideoWindowWidth(g_pCapture, &cx); 
         IltmmCapture_get_VideoWindowHeight(g_pCapture, &cy); 
         SetRect(&rc, x, y, x + cx, y + cy); 
         pt.x = (short) LOWORD(lParam); 
         pt.y = (short) HIWORD(lParam); 
         if(PtInRect(&rc, pt)) 
         { 
            // set the capture properties 
            IltmmCapture_ShowDialog(g_pCapture, ltmmCapture_Dlg_Capture, (long) hwnd); 
         } 
      } 
      return 0; 
      break; 
   } 
   return DefWindowProc(hwnd, message, wParam, lParam); 
} 
int APIENTRY WinMain(HINSTANCE hInstance, 
HINSTANCE hPrevInstance, 
LPSTR     lpCmdLine, 
int       nCmdShow) 
{ 
   MSG msg; 
   HRESULT hr; 
   WNDCLASSEX wcex; 
   UNUSED_PARAMETER (hPrevInstance); 
   UNUSED_PARAMETER (lpCmdLine); 
   g_hInstance = hInstance; 
   // initialize the COM library 
   hr = CoInitialize(NULL); 
   if(FAILED(hr)) 
      goto error; 
   // register the video frame window class 
   wcex.cbSize        = sizeof(WNDCLASSEX); 
   wcex.style         = CS_HREDRAW | CS_VREDRAW; 
   wcex.lpfnWndProc   = CaptureWndProc; 
   wcex.cbClsExtra    = 0; 
   wcex.cbWndExtra    = 0; 
   wcex.hInstance     = g_hInstance; 
   wcex.hIcon         = NULL; 
   wcex.hCursor       = LoadCursor(NULL, IDC_ARROW); 
   wcex.hbrBackground = (HBRUSH) (COLOR_APPWORKSPACE + 1); 
   wcex.lpszMenuName  = (LPCSTR)IDR_MENU; 
   wcex.lpszClassName = SZ_WNDCLASS_CAPTURE; 
   wcex.hIconSm       = NULL; 
   if(!RegisterClassEx(&wcex)) 
      goto error; 
   // create the capture object 
   hr = CoCreateInstance(&CLSID_ltmmCapture, NULL, CLSCTX_INPROC_SERVER, &IID_IltmmCapture, (void**) &g_pCapture); 
   if(FAILED(hr)) 
      goto error; 
   // create the video frame window 
   if(!CreateWindow(SZ_WNDCLASS_CAPTURE, _T("Capture"), WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, 
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, g_hInstance, NULL)) 
   goto error; 
   ShowWindow(g_hwndCapture, nCmdShow); 
   UpdateWindow(g_hwndCapture); 
   // process until done 
   while (GetMessage(&msg, NULL, 0, 0)) 
   { 
      TranslateMessage(&msg); 
      DispatchMessage(&msg); 
   } 
error: 
   if(g_pCapture) 
      IUnknown_Release(g_pCapture); 
   CoUninitialize(); 
   return 0; 
}