Advanced Capture Application Example for C++

// include the LEAD Media Foundation TOOLKIT header 
#include "ltmf.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 
IltmfCapture* g_pCapture;      // capture object interface pointer 
// 
// FreeTarget 
// resets target and free asssociated resources 
// 
void FreeTarget(void) 
{ 
   long type; 
   VARIANT var; 
   g_pCapture->get_TargetType(&type); 
   if(type == ltmfCapture_Target_File) 
   { 
      g_pCapture->ResetTarget(); 
   } 
} 
// 
// 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 
   g_pCapture->get_VideoWindowFrame((long*) &hwnd); 
   // get the video dimensions 
   g_pCapture->get_VideoWidth(&cx); 
   g_pCapture->get_VideoHeight(&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; 
   IltmfDevices* pDevices; 
   long index; 
   long l; 
   long l2; 
   BOOL fActive; 
   ltmfSizeMode sm; 
   TCHAR sz[2048]; 
   LPTSTR p; 
   double d; 
   VARIANT var; 
   long x, y, cx, cy; 
   RECT rc; 
   POINT pt; 
   switch (message) 
   { 
   case WM_CREATE: 
      g_hwndCapture = hwnd; 
      // window is the video window frame 
      g_pCapture->put_VideoWindowFrame((long) hwnd); 
      // want notification messages as well 
      g_pCapture->SetNotifyWindow((long) hwnd, WM_CAPTURENOTIFY); 
      // set preview source video only 
      g_pCapture->put_PreviewSource(ltmfCapture_Preview_Video); 
      // enable preview 
      g_pCapture->put_Preview(VARIANT_TRUE); 
      // assign initial frame delay 
      g_pCapture->put_FrameDelay(1.0); 
      // assign a target file 
      bstr = SysAllocString(L"c:\\target.mp4"); 
      g_pCapture->put_TargetFile(bstr); 
      SysFreeString(bstr); 
      // set output format to MP4 
      g_pCapture->put_TargetFormat(ltmfCapture_TargetFormat_MP4); 
#ifdef _DEBUG 
      { 
         long v; 
         g_pCapture->get_TargetFormat(&v); 
         assert(v == ltmfCapture_TargetFormat_MP4); 
      } 
#endif 
      // get target format 
      IltmfTargetFormats* pTargetFormats; 
      IltmfTargetFormat*  pTargetFormat; 
      g_pCapture->get_TargetFormats(&pTargetFormats); 
      long v; 
      pTargetFormats->get_Selection(&v); 
      pTargetFormats->Item(v, &pTargetFormat); 
      pTargetFormats->Release(); 
      // get target video formats 
      IltmfTargetVideoFormats* pTargetVideoFormats; 
      pTargetFormat->get_VideoFormats(&pTargetVideoFormats); 
      // select the H264 target video format 
      bstr = SysAllocString(L"{34363248-0000-0010-8000-00AA00389B71}"); 
      pTargetVideoFormats->Find(bstr, &index); 
      SysFreeString(bstr); 
      if(index < 0) 
      { 
         // video target format isn't registered 
         pTargetFormat->Release(); 
         pTargetVideoFormats->Release(); 
         return E_FAIL; 
      } 
      pTargetVideoFormats->put_Selection(index); 
      pTargetVideoFormats->Release(); 
      // get target audio formats 
      IltmfTargetAudioFormats* pTargetAudioFormats; 
      pTargetFormat->get_AudioFormats(&pTargetAudioFormats); 
      // select the AAC target audio format 
      bstr = SysAllocString(L"{00001610-0000-0010-8000-00AA00389B71}"); 
      pTargetAudioFormats->Find(bstr, &index); 
      SysFreeString(bstr); 
      if(index < 0) 
      { 
         // audio target format isn't registered 
         pTargetFormat->Release(); 
         pTargetAudioFormats->Release(); 
         return E_FAIL; 
      } 
      pTargetAudioFormats->put_Selection(index); 
      pTargetAudioFormats->Release(); 
      pTargetFormat->Release(); 
      // select the first audio device available 
      g_pCapture->get_AudioDevices(&pDevices); 
      pDevices->put_Selection(0); 
      pDevices->Release(); 
      // select the first video device available 
      g_pCapture->get_VideoDevices(&pDevices); 
      pDevices->put_Selection(0); 
      pDevices->Release(); 
      SnapFrameToVideo(); 
      return 0; 
      break; 
   case WM_CAPTURENOTIFY: 
      switch(wParam) 
      { 
   case ltmfCapture_Notify_Started: 
         _stprintf(sz, _T("Started")); 
         SetWindowText(hwnd, sz); 
         break; 
   case ltmfCapture_Notify_Complete: 
         g_pCapture->get_Mode(&l); 
         if(l == ltmfCapture_Mode_Still) 
         { 
            _stprintf(sz, _T("Complete - [still]")); 
         } 
         else 
         { 
            g_pCapture->get_TargetType(&l); 
            if(l == ltmfCapture_Target_File) 
            { 
               g_pCapture->get_TargetFile(&bstr); 
               _stprintf(sz, _T("Complete - [%ls]"), bstr); 
               SysFreeString(bstr); 
            } 
         } 
         SetWindowText(hwnd, sz); 
         break; 
   case ltmfCapture_Notify_ErrorAbort: 
         _stprintf(sz, _T("Error 0x%.8X. Capture stopped."), lParam); 
         MessageBox(hwnd, sz, _T("Play"), MB_ICONEXCLAMATION | MB_OK); 
         break; 
   case ltmfCapture_Notify_Progress: 
         p = sz; 
         *p = _T('\0'); 
         hr = g_pCapture->get_NumDropped(&l); 
         if(SUCCEEDED(hr)) 
         { 
            if(p != sz) 
               p += _stprintf(p, _T(", ")); 
            p += _stprintf(p, _T("Dropped: %d"), l); 
         } 
         hr = g_pCapture->get_NumNotDropped(&l); 
         if(SUCCEEDED(hr)) 
         { 
            if(p != sz) 
               p += _stprintf(p, _T(", ")); 
            p += _stprintf(p, _T("Not Dropped: %d"), l); 
         } 
         hr = g_pCapture->get_AverageFrameSize(&l); 
         if(SUCCEEDED(hr)) 
         { 
            if(p != sz) 
               p += _stprintf(p, _T(", ")); 
            p += _stprintf(p, _T("Frame Size: %d"), l); 
         } 
         g_pCapture->get_Mode(&l); 
         if(l != ltmfCapture_Mode_Still || l != ltmfCapture_Mode_ManualFrames) 
         { 
            // only display the capture time for free running captures 
            hr = g_pCapture->get_CaptureTime(&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 
         g_pCapture->get_FullScreenMode(&f); 
         if(f) 
         { 
            g_pCapture->put_FullScreenMode(VARIANT_FALSE); 
            return 0; 
         } 
      } 
      break; 
   case WM_DESTROY: 
      FreeTarget(); 
      // no video frame 
      g_pCapture->put_VideoWindowFrame((long) NULL); 
      // no more notifications 
      g_pCapture->SetNotifyWindow((long) NULL, 0); 
      PostQuitMessage(0); 
      break; 
   case WM_INITMENUPOPUP: 
      if(GetSubMenu(GetMenu(hwnd), 0) == (HMENU)wParam) 
      { 
         // determine whether the object is active 
         g_pCapture->get_State(&l); 
         fActive = (l == ltmfCapture_State_Pending || l == ltmfCapture_State_Running); 
         // 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 == ltmfCapture_State_Paused) ? MF_ENABLED : MF_GRAYED); 
         // enable pause if running or pending 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_PAUSE, (l == ltmfCapture_State_Running || l == ltmfCapture_State_Pending) ? MF_ENABLED : MF_GRAYED); 
         // can perform normal capture? 
         g_pCapture->IsModeAvailable(ltmfCapture_Mode_VideoOrAudio, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_STARTCAPTURE, f ? MF_ENABLED : MF_GRAYED); 
         // can perform auto frame capture? 
         g_pCapture->IsModeAvailable(ltmfCapture_Mode_AutoFrames, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREAUTOFRAMES, f ? MF_ENABLED : MF_GRAYED); 
         // can perform manual frame capture? 
         g_pCapture->IsModeAvailable(ltmfCapture_Mode_ManualFrames, &f); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_CAPTUREMANUALFRAMES, f ? MF_ENABLED : MF_GRAYED); 
         // can perform still image capture? 
         g_pCapture->IsModeAvailable(ltmfCapture_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 the current video size mode 
         g_pCapture->get_VideoWindowSizeMode(&sm); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_FITTOWINDOW, (sm == ltmfFit) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_STRETCHTOWINDOW, (sm == ltmfStretch) ? MF_CHECKED : MF_UNCHECKED); 
         // check preview 
         g_pCapture->get_Preview(&f); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PREVIEW, f ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_PREVIEW, !fActive ? MF_ENABLED : MF_GRAYED); 
         // check preview audio 
         g_pCapture->get_PreviewSource(&l); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PREVIEWVIDEOANDAUDIO, (l == ltmfCapture_Preview_VideoAndAudio) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_PREVIEWVIDEOANDAUDIO, !fActive ? MF_ENABLED : MF_GRAYED); 
         // check frame rate 
         g_pCapture->get_UseFrameRate(&f); 
         g_pCapture->get_FrameRate(&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 time limit 
         g_pCapture->get_UseTimeLimit(&f); 
         g_pCapture->get_TimeLimit(&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 frame delay 
         g_pCapture->get_FrameDelay(&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 target 
         g_pCapture->get_TargetType(&l); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGET_FILE, (l == ltmfCapture_Target_File) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGET_FILE, (!fActive) ? MF_ENABLED : MF_GRAYED); 
         // check target format 
         g_pCapture->get_TargetFormat(&l); 
         g_pCapture->get_TargetType(&l2); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_MP4, (l == ltmfCapture_TargetFormat_MP4) ? MF_CHECKED : MF_UNCHECKED); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_WMV, (l == ltmfCapture_TargetFormat_WMV) ? MF_CHECKED : MF_UNCHECKED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_MP4, (!fActive && l2 == ltmfCapture_Target_File) ? MF_ENABLED : MF_GRAYED); 
         EnableMenuItem((HMENU) wParam, ID_CONTROL_TARGETFORMAT_WMV, (!fActive && l2 == ltmfCapture_Target_File) ? MF_ENABLED : MF_GRAYED); 
         // check properties preview 
         g_pCapture->get_ShowDialogPreview(&f); 
         CheckMenuItem((HMENU) wParam, ID_CONTROL_PROPERTIESPREVIEW, (f) ? MF_CHECKED : MF_UNCHECKED); 
      } 
      break; 
   case WM_COMMAND: 
      switch(LOWORD(wParam)) 
      { 
   case ID_CONTROL_FITTOWINDOW: 
         // fit the video to the window 
         g_pCapture->put_VideoWindowSizeMode(ltmfFit); 
         return 0; 
         break; 
   case ID_CONTROL_STRETCHTOWINDOW: 
         // stretch the video to the window 
         g_pCapture->put_VideoWindowSizeMode(ltmfStretch); 
         return 0; 
         break; 
   case ID_CONTROL_FULLSCREEN: 
         // toggle fullscreen mode 
         g_pCapture->ToggleFullScreenMode(); 
         return 0; 
         break; 
   case ID_CONTROL_PREVIEW: 
         // toggle preview 
         g_pCapture->TogglePreview(); 
         return 0; 
         break; 
   case ID_CONTROL_PREVIEWVIDEOANDAUDIO: 
         // toggle audio preview 
         g_pCapture->get_PreviewSource(&l); 
         if(l == ltmfCapture_Preview_VideoAndAudio) 
            g_pCapture->put_PreviewSource(ltmfCapture_Preview_Video); 
         else 
            g_pCapture->put_PreviewSource(ltmfCapture_Preview_VideoAndAudio); 
         return 0; 
         break; 
   case ID_CONTROL_STOPCAPTURE: 
         // stop capturing 
         g_pCapture->StopCapture(); 
         return 0; 
         break; 
   case ID_CONTROL_STARTCAPTURE: 
         // ready capture to eliminate start delays 
         hr = g_pCapture->ReadyCapture(ltmfCapture_Mode_VideoOrAudio); 
         if(SUCCEEDED(hr)) 
         { 
            if(MessageBox(hwnd, _T("Ready to capture. Click 'ok' to start."), _T("Capture"), MB_OKCANCEL) == IDOK) 
            { 
               // start capturing 
               g_pCapture->StartCapture(ltmfCapture_Mode_VideoOrAudio); 
            } 
            else 
            { 
               // cancel capture 
               g_pCapture->StopCapture(); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_RUN: 
         // run the capture graph 
         g_pCapture->RunCapture(); 
         return 0; 
         break; 
   case ID_CONTROL_PAUSE: 
         // pause the capture graph 
         g_pCapture->PauseCapture(); 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREAUTOFRAMES: 
         hr = g_pCapture->ReadyCapture(ltmfCapture_Mode_AutoFrames); 
         if(SUCCEEDED(hr)) 
         { 
            // start capturing automatic frame sequence 
            g_pCapture->StartCapture(ltmfCapture_Mode_AutoFrames); 
         } 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREMANUALFRAMES: 
         hr = g_pCapture->ReadyCapture(ltmfCapture_Mode_ManualFrames); 
         if(SUCCEEDED(hr)) 
         { 
            // start capturing automatic frame sequence 
            hr = g_pCapture->StartCapture(ltmfCapture_Mode_ManualFrames); 
            if(SUCCEEDED(hr)) 
            { 
               while(MessageBox(hwnd, _T("Press 'ok' to capture frame."), _T("Capture Manual Frames"), MB_OKCANCEL) == IDOK) 
               g_pCapture->CaptureFrame(); 
               g_pCapture->StopCapture(); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_CAPTUREDIB: 
         // capture device independent bitmap 
         hr = g_pCapture->CaptureDIB((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 ole picture object 
         hr = g_pCapture->CapturePicture(&pPictureDisp); 
         if(SUCCEEDED(hr)) 
         { 
            // save the picture 
            bstr = SysAllocString(L"c:\\still.bmp"); 
            OleSavePictureFile(pPictureDisp, bstr); 
            SysFreeString(bstr); 
            pPictureDisp->Release(); 
         } 
         return 0; 
         break; 
   case ID_CONTROL_GETSTILLDIB: 
         // alternate method of capturing a device independent bitmap 
         hr = g_pCapture->StartCapture(ltmfCapture_Mode_Still); 
         if(SUCCEEDED(hr)) 
         { 
            hr = g_pCapture->GetStillDIB(INFINITE, (long*) &hDIB); 
            g_pCapture->StopCapture(); 
            if(SUCCEEDED(hr)) 
            { 
               // copy to the clipboard 
               OpenClipboard(hwnd); 
               EmptyClipboard(); 
               SetClipboardData(CF_DIB, hDIB); 
               CloseClipboard(); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_GETSTILLPICTURE: 
         // alternate method of capturing an ole picture object 
         hr = g_pCapture->StartCapture(ltmfCapture_Mode_Still); 
         if(SUCCEEDED(hr)) 
         { 
            hr = g_pCapture->GetStillPicture(INFINITE, &pPictureDisp); 
            g_pCapture->StopCapture(); 
            if(SUCCEEDED(hr)) 
            { 
               // save the picture 
               bstr = SysAllocString(L"c:\\still.bmp"); 
               OleSavePictureFile(pPictureDisp, bstr); 
               SysFreeString(bstr); 
               pPictureDisp->Release(); 
            } 
         } 
         return 0; 
         break; 
   case ID_CONTROL_FRAMERATE_DEFAULT: 
         // set rate to default 
         g_pCapture->put_UseFrameRate(VARIANT_FALSE); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMERATE_15FPS: 
         // set rate to 15 fps 
         g_pCapture->put_FrameRate(15.0); 
         g_pCapture->put_UseFrameRate(VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMERATE_30FPS: 
         // set rate to 30 fps 
         g_pCapture->put_FrameRate(30.0); 
         g_pCapture->put_UseFrameRate(VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_TIMELIMIT_NONE: 
         // no time limit 
         g_pCapture->put_UseTimeLimit(VARIANT_FALSE); 
         return 0; 
         break; 
   case ID_CONTROL_TIMELIMIT_15SEC: 
         // 15 sec time limit 
         g_pCapture->put_TimeLimit(15.0); 
         g_pCapture->put_UseTimeLimit(VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_TIMELIMIT_30SEC: 
         // 30 sec time limit 
         g_pCapture->put_TimeLimit(30.0); 
         g_pCapture->put_UseTimeLimit(VARIANT_TRUE); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMEDELAY_1SEC: 
         // 1 sec frame delay 
         g_pCapture->put_FrameDelay(1.0); 
         return 0; 
         break; 
   case ID_CONTROL_FRAMEDELAY_5SEC: 
         // 5 sec frame delay 
         g_pCapture->put_FrameDelay(5.0); 
         return 0; 
         break; 
   case ID_CONTROL_TARGET_FILE: 
         // assign a target file 
         FreeTarget(); 
         // set output format to MP4 
         g_pCapture->put_TargetFormat(ltmfCapture_TargetFormat_MP4); 
#ifdef _DEBUG 
         { 
            long v; 
            g_pCapture->get_TargetFormat(&v); 
            assert(v == ltmfCapture_TargetFormat_MP4); 
         } 
#endif 
         // get target format 
         IltmfTargetFormats* pTargetFormats; 
         IltmfTargetFormat*  pTargetFormat; 
         g_pCapture->get_TargetFormats(&pTargetFormats); 
         long v; 
         pTargetFormats->get_Selection(&v); 
         pTargetFormats->Item(v, &pTargetFormat); 
         pTargetFormats->Release(); 
         // get target video formats 
         IltmfTargetVideoFormats* pTargetVideoFormats; 
         pTargetFormat->get_VideoFormats(&pTargetVideoFormats); 
         // select the H264 video target video format 
         bstr = SysAllocString(L"{34363248-0000-0010-8000-00AA00389B71}"); 
         pTargetVideoFormats->Find(bstr, &index); 
         SysFreeString(bstr); 
         if(index < 0) 
         { 
            // video target format isn't registered 
            pTargetFormat->Release(); 
            pTargetVideoFormats->Release(); 
            return E_FAIL; 
         } 
         pTargetVideoFormats->put_Selection(index); 
         pTargetVideoFormats->Release(); 
         // get target audio formats 
         IltmfTargetAudioFormats* pTargetAudioFormats; 
         pTargetFormat->get_AudioFormats(&pTargetAudioFormats); 
         // select the AAC target audio format 
         bstr = SysAllocString(L"{00001610-0000-0010-8000-00AA00389B71}"); 
         pTargetAudioFormats->Find(bstr, &index); 
         SysFreeString(bstr); 
         if(index < 0) 
         { 
            // audio target format isn't registered 
            pTargetFormat->Release(); 
            pTargetAudioFormats->Release(); 
            return E_FAIL; 
         } 
         pTargetAudioFormats->put_Selection(index); 
         pTargetAudioFormats->Release(); 
         pTargetFormat->Release(); 
         return 0; 
         break; 
   case ID_CONTROL_TARGETFORMAT_MP4: 
         // is target a file? 
         g_pCapture->get_TargetType(&l); 
         if(l == ltmfCapture_Target_File) 
         { 
            // rename it 
            bstr = SysAllocString(L"c:\\target.mp4"); 
            g_pCapture->put_TargetFile(bstr); 
            SysFreeString(bstr); 
         } 
         g_pCapture->put_TargetFormat(ltmfCapture_TargetFormat_MP4); 
         return 0; 
         break; 
   case ID_CONTROL_TARGETFORMAT_WMV: 
         // is target a file? 
         g_pCapture->get_TargetType(&l); 
         if(l == ltmfCapture_Target_File) 
         { 
            // rename it 
            bstr = SysAllocString(L"c:\\target.wmv"); 
            g_pCapture->put_TargetFile(bstr); 
            SysFreeString(bstr); 
         } 
         g_pCapture->put_TargetFormat(ltmfCapture_TargetFormat_WMV); 
         return 0; 
         break; 
   case ID_CONTROL_AUDIOPROCESSORS: 
         // edit audio processors 
         g_pCapture->ShowDialog(ltmfCapture_Dlg_AudioProcessors, (long) hwnd); 
         return 0; 
         break; 
   case ID_CONTROL_VIDEOPROCESSORS: 
         // edit video processors 
         g_pCapture->ShowDialog(ltmfCapture_Dlg_VideoProcessors, (long) hwnd); 
         return 0; 
         break; 
   case ID_CONTROL_PROPERTIESPREVIEW: 
         // toggle preview while editing properties 
         g_pCapture->get_ShowDialogPreview(&f); 
         g_pCapture->put_ShowDialogPreview(f ? VARIANT_FALSE : VARIANT_TRUE); 
         return 0; 
         break; 
      } 
      break; 
   case WM_LBUTTONDOWN: 
      g_pCapture->get_State(&l); 
      if(l != ltmfCapture_State_Pending || l != ltmfCapture_State_Running) 
      { 
         g_pCapture->get_VideoWindowLeft(&x); 
         g_pCapture->get_VideoWindowTop(&y); 
         g_pCapture->get_VideoWindowWidth(&cx); 
         g_pCapture->get_VideoWindowHeight(&cy); 
         SetRect(&rc, x, y, x + cx, y + cy); 
         pt.x = (short) LOWORD(lParam); 
         pt.y = (short) HIWORD(lParam); 
         if(PtInRect(&rc, pt)) 
         { 
            // set target format properties 
            g_pCapture->ShowDialog(ltmfCapture_Dlg_TargetFormat, (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; 
   g_hInstance = hInstance; 
   // initialize 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   = (LPCWSTR)IDR_MENU; 
   wcex.lpszClassName   = SZ_WNDCLASS_CAPTURE; 
   wcex.hIconSm      = NULL; 
   if(!RegisterClassEx(&wcex)) 
      goto error; 
   // create the capture object 
   hr = CoCreateInstance(CLSID_ltmfCapture, NULL, CLSCTX_INPROC_SERVER, IID_IltmfCapture, (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) 
      g_pCapture->Release(); 
   CoUninitialize(); 
   return 0; 
}