Regarding Desktop Video capture Using VC++

See more:

C++

i have download the project from microsoft using WMEncoder to capture a desktop activities as video. Its working fine. But the problem is it capture a full screen but i need to capture the specific window. The main problem is video frame width and height is desktop screen resolution size. The video is playing very in computer but it is not playing in DVD player. I am new to VC++ thats y i dono how to change the coding for my purpose. Please help me to solve this issue....

Thanks in Advance

Code is:

#define    WM_NOTIFYICON_MESSAGE    WM_USER+1000

#define CONTENT_TYPE_VIDEO_ONLY        16        //Profile Supports Only Video
#define CONTENT_TYPE_AUDIO_VIDEO    17        //Profile Supports both audio and Video

#define PROFILE_CONTENT_TYPE        CONTENT_TYPE_VIDEO_ONLY        //Change this to Audio_Video for Audio support

#define PROFILE_AUDIENCE_BITRATE    400000    //Target for 400 Kbps

#define VIDEOCODEC                    MAKEFOURCC('M','S','S','2')

#define VIDEOFRAMERATE                30        //15 FPS(Frames Per Second)

#define IMAGEQUALITY                100        // 0 ~ 100: The higher the number the better the quality

#define CAPTURE_FULLSCREEN            false    //By Default We capture Full Screen - If false set the coordinates

#define    WMSRCNCAP_CAPTUREWINDOW        CComBSTR("CaptureWindow")    //Property of Source Video - Fullscreen Mode

#define WMSCRNCAP_WINDOWLEFT        CComBSTR("Left")
#define WMSCRNCAP_WINDOWTOP         CComBSTR("Top")
#define WMSCRNCAP_WINDOWRIGHT       CComBSTR("Right")
#define WMSCRNCAP_WINDOWBOTTOM      CComBSTR("Bottom")
#define WMSCRNCAP_FLASHRECT         CComBSTR("FlashRect")
#define WMSCRNCAP_ENTIRESCREEN      CComBSTR("Screen")
#define WMSCRNCAP_WINDOWTITLE       CComBSTR("WindowTitle")

//#define WMSCRNCAP_WINDOWLEFT        CComBSTR("150")
//#define WMSCRNCAP_WINDOWTOP         CComBSTR("100")
//#define WMSCRNCAP_WINDOWRIGHT       CComBSTR("150")
//#define WMSCRNCAP_WINDOWBOTTOM      CComBSTR("100")
//#define WMSCRNCAP_FLASHRECT         CComBSTR("FlashRect")
//#define WMSCRNCAP_ENTIRESCREEN      CComBSTR("Screen")
//#define WMSCRNCAP_WINDOWTITLE       CComBSTR("WindowTitle")


#define ErrorMessage(x)    MessageBox(NULL,x,"Error",MB_OK|MB_ICONERROR)


HINSTANCE    hInst;                                
TCHAR        szTitle[MAX_LOADSTRING];            
TCHAR        szWindowClass[MAX_LOADSTRING];        
HMENU        ghMenu=NULL;                                //Menu Handle for the Popup Menu

IWMEncoder2*        g_pEncoder=NULL;    
IWMEncProfile2*        g_pProfile=NULL;

HRESULT                SetupScreenCaptureProfile();        //Creates and Initializes the Custom Profile Settings for ScreenCapture Codec
void                Cleanup();                            //The Exit Function for the Encoder Objects
HRESULT                InitEncoder(LPCTSTR);                //The Entry Function for the Encoder Objects

ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    MSG msg;
    HACCEL hAccelTable;

    CoInitialize(NULL);                    //Initialize COM

    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_WMENCSCRNCAP, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    if (!InitInstance (hInstance, nCmdShow)) 
    {
        return FALSE;
    }

    hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_WMENCSCRNCAP);

    while (GetMessage(&msg, NULL, 0, 0)) 
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    CoUninitialize();                    //Cleanup COM

    return (int) msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX); 

    wcex.style            = CS_HREDRAW | CS_VREDRAW ;
    wcex.lpfnWndProc    = (WNDPROC)WndProc;
    wcex.cbClsExtra        = 0;
    wcex.cbWndExtra        = 0;
    wcex.hInstance        = hInstance;
    wcex.hIcon            = LoadIcon(hInstance, (LPCTSTR)IDI_WMENCSCRNCAP);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground    = (HBRUSH)(BLACK_BRUSH);
    wcex.lpszMenuName    = (LPCTSTR)IDC_WMENCSCRNCAP;
    wcex.lpszClassName    = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

    return RegisterClassEx(&wcex);
}

//
//   FUNCTION: InitInstance(HANDLE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // Store instance handle in our global variable

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT, 480, 320, NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND    - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY    - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static NOTIFYICONDATA    nid;
    static bool    bMinimized=false;
    static RECT    clientRect = {0,0,0,0};
    DWORD    wmId,wmEvent;
    switch (message) 
    {
    case WM_SYSCOMMAND:
        {
            if(g_pEncoder)
            {
                if(wParam==SC_CLOSE)
                {
                        SendMessage(hWnd,WM_SYSCOMMAND,SC_MINIMIZE,0);                        //Give the effect of minimize
                        return 0;
                }            
                if(wParam==SC_MINIMIZE)
                {
                    bMinimized=true;
                    LONG_PTR ret=DefWindowProc(hWnd,message,wParam,lParam);                //Run the Minimize Animation
                    SendMessage(hWnd,WM_COMMAND,MAKEWPARAM(ID_FILE_HIDEWINDOW,0),0);    //Then Hide it
                    return ret;
                }
            }
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    case WM_COMMAND:
        {
            wmId    = LOWORD(wParam); 
            wmEvent = HIWORD(wParam); 
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
                break;
            case ID_FILE_STARTCAPTURE:
            case ID_CAPTURE_START:
                {
                    if(g_pEncoder==NULL)
                    {
                        OPENFILENAME    ofn;
                        char    szFileName[512];
                        strcpy(szFileName,"Output.wmv");
                        ZeroMemory(&ofn,sizeof(ofn));
                        ofn.lStructSize=sizeof(OPENFILENAME);
                        ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
                        ofn.lpstrFilter="Video Files (*.wmv)\0*.wmv\0 ";
                        //ofn.lpstrFilter = "All Files (*.*)|*.*";
                        ofn.lpstrDefExt="wmv";    
                        
                        ofn.lpstrFile=szFileName;
                        ofn.nMaxFile=512;
                        if(!GetSaveFileName(&ofn))    break;
                    
                        SendMessage(hWnd,WM_SYSCOMMAND,SC_MINIMIZE,0);
                        ShowWindow(hWnd,SW_HIDE);

                        if(FAILED(InitEncoder(szFileName)))    
                        {
                            DestroyWindow(hWnd);
                            //ShowWindow(hWnd,SW_RESTORE);
                            break;
                        }
                    }
                
                    nid.uFlags=NIF_ICON|NIF_MESSAGE|NIF_TIP;            //Set the Notification Message
                    nid.uCallbackMessage=WM_NOTIFYICON_MESSAGE;
                    nid.hIcon=LoadIcon(hInst,MAKEINTRESOURCE(IDI_ICON_PAUSE));
                    strcpy(nid.szTip,"Capturing the Screen - Click to Pause");

                    if(!Shell_NotifyIcon(NIM_MODIFY,&nid))                //Modify the Icon State
                        MessageBox(NULL,"Unable to Set Notification Icon","Error",MB_ICONINFORMATION|MB_OK);

                    SendMessage(hWnd,WM_SYSCOMMAND,SC_MINIMIZE,0);

                    if(FAILED(g_pEncoder->Start()))
                        ErrorMessage("Unable to Start Encoding Process");                    

                    break;
                }
            case ID_FILE_PAUSECAPTURE:
            case ID_CAPTURE_PAUSE:
                {                
                    nid.hIcon=LoadIcon(hInst,MAKEINTRESOURCE(IDI_ICON_START));
                    strcpy(nid.szTip,"Screen Capture Paused - Click to Resume");

                    if(!Shell_NotifyIcon(NIM_MODIFY,&nid))                //Modify the Icon State
                        MessageBox(NULL,"Unable to Set Notification Icon","Error",MB_ICONINFORMATION|MB_OK);

                    if(FAILED(g_pEncoder->Pause()))
                    {
                        ErrorMessage("Unable to Pause the Encoder");
                    }
                    InvalidateRect(hWnd,NULL,false);
                    break;
                }
            case ID_FILE_SHOWWINDOW:
                {
                    if(bMinimized)    ShowWindow(hWnd,SW_RESTORE);
                    else            ShowWindow(hWnd,SW_SHOW);
                    SetForegroundWindow(hWnd);
                    bMinimized=false;
                    break;
                }
            case ID_FILE_HIDEWINDOW:
                {
                    ShowWindow(hWnd,SW_HIDE);
                    break;
                }
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
            break;
        }
    case WM_CREATE:
        {
            ZeroMemory(&nid,sizeof(nid));
            nid.cbSize=sizeof(nid);
            nid.uID=1000;
            nid.uFlags=NIF_ICON|NIF_TIP;
            nid.hIcon=LoadIcon(hInst,MAKEINTRESOURCE(IDI_WMENCSCRNCAP));
            nid.hWnd=hWnd;
            strcpy(nid.szTip,"Screen Capture Application");
            if(!Shell_NotifyIcon(NIM_ADD,&nid))    MessageBox(NULL,"Unable to Set Notification Icon","Error",MB_ICONINFORMATION|MB_OK);
            ghMenu=LoadMenu(hInst,MAKEINTRESOURCE(IDC_WMENCSCRNCAP));
            break;
        }
    case WM_CHAR:
        {
            if(wParam==VK_ESCAPE)
                DestroyWindow(hWnd);    //DestroyWindow calls cleanup() - it would stop the encoder
            break;
        }
    case WM_INITMENU:
        {
            HMENU    hMenu = (HMENU)wParam;
            WMENC_ENCODER_STATE    encState=WMENC_ENCODER_STOPPED ;
            if(g_pEncoder)    g_pEncoder->get_RunState(&encState);
            bool bCapturing = (encState!=WMENC_ENCODER_PAUSED && encState!=WMENC_ENCODER_STOPPED);
            EnableMenuItem(hMenu,ID_FILE_SHOWWINDOW,IsWindowVisible(hWnd)?MF_GRAYED:MF_ENABLED|MF_BYCOMMAND);
            if(g_pEncoder)    EnableMenuItem(hMenu,ID_FILE_HIDEWINDOW,IsWindowVisible(hWnd)?MF_ENABLED:MF_GRAYED|MF_BYCOMMAND);
            EnableMenuItem(hMenu,ID_FILE_STARTCAPTURE,bCapturing?MF_GRAYED|MF_BYCOMMAND:MF_ENABLED);
            EnableMenuItem(hMenu,ID_FILE_PAUSECAPTURE,bCapturing?MF_ENABLED:MF_GRAYED|MF_BYCOMMAND);
            EnableMenuItem(hMenu,ID_CAPTURE_START,bCapturing?MF_GRAYED|MF_BYCOMMAND:MF_ENABLED);
            EnableMenuItem(hMenu,ID_CAPTURE_PAUSE,bCapturing?MF_ENABLED:MF_GRAYED|MF_BYCOMMAND);            
            break;
        }
    case WM_INITMENUPOPUP:
        {
            WMENC_ENCODER_STATE    encState=WMENC_ENCODER_STOPPED ;
            if(g_pEncoder)    g_pEncoder->get_RunState(&encState);
            bool bCapturing = (encState!=WMENC_ENCODER_PAUSED && encState!=WMENC_ENCODER_STOPPED);
            EnableMenuItem(ghMenu,ID_FILE_SHOWWINDOW,IsWindowVisible(hWnd)?MF_GRAYED:MF_ENABLED|MF_BYCOMMAND);
            EnableMenuItem(ghMenu,ID_FILE_HIDEWINDOW,IsWindowVisible(hWnd)?MF_ENABLED:MF_GRAYED|MF_BYCOMMAND);
            EnableMenuItem(ghMenu,ID_FILE_STARTCAPTURE,bCapturing?MF_GRAYED|MF_BYCOMMAND:MF_ENABLED);
            EnableMenuItem(ghMenu,ID_FILE_PAUSECAPTURE,bCapturing?MF_ENABLED:MF_GRAYED|MF_BYCOMMAND);
            EnableMenuItem(ghMenu,ID_CAPTURE_START,bCapturing?MF_GRAYED|MF_BYCOMMAND:MF_ENABLED);
            EnableMenuItem(ghMenu,ID_CAPTURE_PAUSE,bCapturing?MF_ENABLED:MF_GRAYED|MF_BYCOMMAND);            
            break;
        }
    case WM_PAINT:
        {
            WMENC_ENCODER_STATE    encState=WMENC_ENCODER_STOPPED ;
            if(g_pEncoder)    g_pEncoder->get_RunState(&encState);
            bool bCapturing = (encState!=WMENC_ENCODER_PAUSED && encState!=WMENC_ENCODER_STOPPED);
            const char* strMsg[]={"Click Start From Capture Menu to Start/Resume the Screen Capture","Click Pause From Capture Menu to Pause the Screen Capture"};
            PAINTSTRUCT ps;
            HDC hdc=BeginPaint(hWnd,&ps);    
            DrawText(hdc,strMsg[bCapturing],(int)strlen(strMsg[bCapturing]),&clientRect,DT_CENTER|DT_SINGLELINE|DT_VCENTER);
            EndPaint(hWnd,&ps);
            break;
        }
    case WM_SIZE:
        {
            clientRect.right = LOWORD(lParam);
            clientRect.bottom= HIWORD(lParam);
            break;
        }
    case WM_NOTIFYICON_MESSAGE:
        {
            switch(lParam)
            {
                case WM_MOUSEMOVE:break;
                case WM_LBUTTONDOWN:
                    {                        
                        WMENC_ENCODER_STATE    encState=WMENC_ENCODER_STOPPED;    //By Default Assume Stopped state
                        g_pEncoder->get_RunState(&encState);
                        if(encState == WMENC_ENCODER_RUNNING)
                            SendMessage(hWnd,WM_COMMAND,MAKEWPARAM(ID_FILE_PAUSECAPTURE,0),0);
                        if(encState == WMENC_ENCODER_PAUSED || encState == WMENC_ENCODER_STOPPED)
                            SendMessage(hWnd,WM_COMMAND,MAKEWPARAM(ID_FILE_STARTCAPTURE,0),0);
                        break;
                    }
                case WM_RBUTTONDOWN:
                    {
                        POINT pt;GetCursorPos(&pt);
                        SetForegroundWindow(hWnd);
                        TrackPopupMenu(GetSubMenu(ghMenu,0),TPM_LEFTALIGN|TPM_BOTTOMALIGN,pt.x,pt.y,0,hWnd,NULL);
                        break;
                    }
            }
            break;
        }
    case WM_DESTROY:
        {
            Shell_NotifyIcon(NIM_DELETE,&nid);
            DestroyMenu(ghMenu);
            Cleanup();
            PostQuitMessage(0);
            break;
        }
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_INITDIALOG:
        return TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
        {
            EndDialog(hDlg, LOWORD(wParam));
            return TRUE;
        }
        break;
    }
    return FALSE;
}


HRESULT    SetupScreenCaptureProfile()                                        //Called by InitEncoder() Function
{    
    IWMEncAudienceObj*    pAudience=NULL;

    if(FAILED(CoCreateInstance(CLSID_WMEncProfile2,NULL,CLSCTX_INPROC_SERVER,IID_IWMEncProfile2,(void**)&g_pProfile)))
    {
        ErrorMessage("Unable to Create Profile Manager");
        return E_FAIL;
    }
    if(FAILED(g_pProfile->put_ValidateMode(true)))                        //Verify the settings immediately as they are set
    {
        ErrorMessage("Unable to Set Validate Mode");
        return E_FAIL;
    }
    if(FAILED(g_pProfile->put_ProfileName(CComBSTR("Custom Screen Capture Profile"))))
    {
        ErrorMessage("Unable to Set Profile Name");
        return E_FAIL;
    }
    if(FAILED(g_pProfile->put_ProfileDescription(CComBSTR("A Custom Video Profile For Screen Capture"))))
    {
        ErrorMessage("Unable to Set Profile Description");
        return E_FAIL;
    }
    if(FAILED(g_pProfile->put_ContentType(PROFILE_CONTENT_TYPE)))        //Content Type for our Profile - By default it is - CONTENT_TYPE_VIDEO_ONLY
    {
        ErrorMessage("Unable to Set Content Type for Profile");
        return E_FAIL;
    }
    if(FAILED(g_pProfile->put_VBRMode(WMENC_VIDEO,0,WMENC_PVM_NONE)))    //Set CBR Mode - Compatible with Older Version Players
    {
        ErrorMessage("Unable to Set BitRate Mode");
        return E_FAIL;
    }
    if(FAILED(g_pProfile->AddAudience(PROFILE_AUDIENCE_BITRATE,&pAudience)))
    {
        ErrorMessage("Unable to Set Target Audience");
        return E_FAIL;
    }

    do
    {
        long lCodecIndex=-1;
        if(FAILED(g_pProfile->GetCodecIndexFromFourCC(WMENC_VIDEO,VIDEOCODEC,&lCodecIndex)))
        {
            ErrorMessage("Unable to Get Codec Index");
            break;
        }
        if(FAILED(pAudience->put_VideoCodec(0,lCodecIndex)))            //Set the Codec for the Target Audience
        {
            ErrorMessage("Unable to Set Codec");
            break;
        }
        if(FAILED(pAudience->put_VideoHeight(0,0)))                        //Use the same as the input
        {
            ErrorMessage("Unable to Set Video Height");
            break;
        }
        if(FAILED(pAudience->put_VideoWidth(0,0)))                        //Use the same width as the input
        {
            ErrorMessage("Unable to Set Video Width");
            break;
        }
        if(FAILED(pAudience->put_VideoBufferSize(0,5000)))                //Set buffer size for 5 seconds
        {
            ErrorMessage("Unable to Set Buffer Size");
            break;
        }
        if(FAILED(pAudience->put_VideoFPS(0,VIDEOFRAMERATE * 1000)))    //Set the Video Frame Rate
        {
            ErrorMessage("Unable to Set Video Frame Rate");
            break;
        }
        if(FAILED(pAudience->put_VideoImageSharpness(0,IMAGEQUALITY)))    //Set the Best Image Sharpness possible
        {
            ErrorMessage("Unable to Set Video Image Sharpness");
            break;
        }
        if(FAILED(g_pProfile->Validate()))                                //Test the Profile Settings
        {
            ErrorMessage("Unable to Validate the Profile Settings");
            break;
        }
        if(pAudience)
        {
            pAudience->Release();
            pAudience=NULL;
        }
        return S_OK;

    }while(false);
    
    if(pAudience)                        //Control Reaches here only in case of errors 
    {
        pAudience->Release();
        pAudience=NULL;
    }
    return E_FAIL;
}

HRESULT    InitEncoder(LPCTSTR szOutputFileName)
{
    HRESULT    hr = E_FAIL;
    CComVariant varValue;
    IWMEncSourceGroupCollection*    pSrcGrpCollection=NULL;
    IWMEncSourceGroup*    pSrcGrp=NULL;
    IWMEncSource*    pSrc=NULL;
    IPropertyBag*    pPropertyBag=NULL;
    IWMEncVideoSource2*    pSrcVid=NULL;
    IWMEncFile*    pOutFile=NULL;
    IWMEncProfile*    pProfile=NULL;

    if(FAILED(CoCreateInstance(CLSID_WMEncoder,NULL,CLSCTX_INPROC_SERVER,IID_IWMEncoder2,(void**)&g_pEncoder)))
    {
        ErrorMessage("Unable to Create Encoder Object");
        return E_FAIL;
    }
    if(FAILED(g_pEncoder->get_SourceGroupCollection(&pSrcGrpCollection)))        //Retrieve the Source Group Collection    - One Application can Have many Source Groups - We need to add as many as we want
    {
        ErrorMessage("Unable to Get Source Group Collection");
        return E_FAIL;
    }

    do
    {
        if(FAILED(hr=pSrcGrpCollection->Add(CComBSTR("SourceGroup1"),&pSrcGrp)))//Add a Source Group to the Collection - Each Source can have one video one audio source input
        {
            ErrorMessage("Unable to Add A Source Group to the Collection");
            break;
        }
        if(FAILED(hr=pSrcGrp->AddSource(WMENC_VIDEO,&pSrc)))                    //Add a Video Source to the Group
        {
            ErrorMessage("Unable to Add A Source to the Source Group");
            break;
        }
        if(FAILED(hr=pSrc->QueryInterface(IID_IWMEncVideoSource2,(void**)&pSrcVid)))
        {
            ErrorMessage("Unable to Query interface for Video Source");
            break;
        }
        if(FAILED(hr=pSrcVid->SetInput(CComBSTR("ScreenCap://ScreenCapture1"))))//The Video Input Source Device - Should be "ScreenCap" Device
        {
            ErrorMessage("Unable to Set Video Input Source");
            break;
        }
        if(FAILED(hr=pSrcVid->QueryInterface(IID_IPropertyBag,(void**)&pPropertyBag)))
        {
            ErrorMessage("Unable to Query Interface for Propery bag");
            break;
        }

        varValue = CAPTURE_FULLSCREEN;
        if(FAILED(hr=pPropertyBag->Write(WMSCRNCAP_ENTIRESCREEN,&varValue)))    //Set Full Screen Property true/false
        {
            ErrorMessage("Unable to Set Capture Screen Property");
            break;
        }
        //int nLeft, nRight, nTop, nBottom;                                    //Set Capture Area - when not in full screen mode
        //                                                                    // Initialize the capture area. The size must be even.
        //    varValue = false;
        //    if ( SUCCEEDED( hr ) )
        //    {
        //        hr = pPropertyBag->Write( WMSCRNCAP_ENTIRESCREEN, &varValue );
        //    }
        //    varValue = nLeft;
        //    if ( SUCCEEDED( hr ) )
        //    {
        //        hr = pPropertyBag->Write( WMSCRNCAP_WINDOWLEFT, &varValue );
        //    }
        //    varValue = nRight;
        //    if ( SUCCEEDED( hr ) )
        //    {
        //        hr = pPropertyBag->Write( WMSCRNCAP_WINDOWRIGHT, &varValue );
        //    }
        //    varValue = nTop;
        //    if ( SUCCEEDED( hr ) )
        //    {
        //        hr = pPropertyBag->Write( WMSCRNCAP_WINDOWTOP, &varValue );
        //    }
        //    varValue = nBottom;
        //    if ( SUCCEEDED( hr ) )
        //    {
        //        hr = pPropertyBag->Write( WMSCRNCAP_WINDOWBOTTOM, &varValue );
        //    }
        //    varValue = true;
        //    if ( SUCCEEDED( hr ) )
        //    {
        //        hr = pPropertyBag->Write( WMSCRNCAP_FLASHRECT, &varValue );
        //    }

        if(FAILED(hr=SetupScreenCaptureProfile()))                                    //Setup the Custom Profile
        {
            break;
        }
        if(FAILED(hr=g_pProfile->QueryInterface(IID_IWMEncProfile,(void**)&pProfile)))
        {
            ErrorMessage("Unable to Query Interface For Profile");
            break;
        }
        if(FAILED(hr=pSrcGrp->put_Profile(variant_t(pProfile))))                    //Select the Custom Profile into the Encoder    
        {
            ErrorMessage("Unable to Set Profile For Source Group");
            break;
        }
        if(FAILED(hr=g_pEncoder->get_File(&pOutFile)))
        {
            ErrorMessage("Unable to Get Encoder Output File Object");
            break;
        }
        if(FAILED(hr=pOutFile->put_LocalFileName(CComBSTR(szOutputFileName))))        //Set the Target Output Filename
        {
            ErrorMessage("Unable to Set Output File Name");
            break;
        }
        if(FAILED(hr=g_pEncoder->PrepareToEncode(VARIANT_TRUE)))                    //Using Prepare optimizes startig latency
        {
            ErrorMessage("Unable to Prepare for Encoding");
            break;
        }
    }while(false);

    if(pProfile)
    {
        pProfile->Release();
        pProfile=NULL;
    }
    if(pOutFile)
    {
        pOutFile->Release();
        pOutFile = NULL;
    }
    if(pPropertyBag)
    {
        pPropertyBag->Release();
        pPropertyBag = NULL;
    }
    if(pSrcVid)
    {
        pSrcVid->Release();
        pSrcVid = NULL;
    }
    if(pSrc)
    {
        pSrc->Release();
        pSrc = NULL;
    }
    if(pSrcGrp)
    {
        pSrcGrp->Release();
        pSrcGrp = NULL;
    }
    if(pSrcGrpCollection)
    {
        pSrcGrpCollection->Release();
        pSrcGrpCollection = NULL;
    }
    return hr;
}

void Cleanup()
{
    if(g_pProfile)
    {
        g_pProfile->Release();
        g_pProfile =NULL;
    }
    if(g_pEncoder)
    {
        g_pEncoder->PrepareToEncode(VARIANT_FALSE);        //Prepare to Stop
        g_pEncoder->Stop();
        g_pEncoder->Release();
        g_pEncoder=NULL;
    }
}