Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

Various methods for capturing the screen

, 19 Sep 2006 LGPL3
Explains techniques for capturing the screen programmatically.
screencap.zip
ScreenCap
ico00001.ico
icon1.ico
Release
ScreenCap.exe
ScreenCap.ico
ScreenCap.vcproj.vspscc
ScreenCap.vssscc
small.ico
screencapdx.zip
ScreenCapDx
ico00001.ico
icon1.ico
Release
ScreenCapture.exe
ScreenCapture.7.10.vssscc
ScreenCapture.ico
ScreenCapture.vcproj.vspscc
ScreenCapture.vssscc
small.ico
wmencscrncap.zip
Release
WMEncScrnCap.exe
ico00001.ico
icon1.ico
icon_sta.ico
small.ico
WMEncScrnCap.ico
// WMEncScrnCap.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "WMEncScrnCap.h"
#include <shellapi.h>

#include <wmencode.h>
#include <Atlbase.h>
#include <comdef.h>

#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
                ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |   \
                ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))			//From MMSystem.h

#define MAX_LOADSTRING 100

#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				10		//15 FPS(Frames Per Second)

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

#define CAPTURE_FULLSCREEN			true	//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 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.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 height 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;
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The GNU Lesser General Public License (LGPLv3)

Share

About the Author

Creator of CarMusTy - Carnatic Music Typesetting Application, and the CFugue C++ Runtime Environment for MusicNote Programming.

| Advertise | Privacy | Mobile
Web01 | 2.8.141022.2 | Last Updated 19 Sep 2006
Article Copyright 2003 by Gopalakrishna Palem
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid