main.c

最新版的基于 Windows CE 的视频捕获解决方案

		display_frame_full(rgb, g_uScreenWidth, g_uScreenHeight);
	}
	else
	{
		display_frame(rgb, g_rcDisplay.right-g_rcDisplay.left, g_rcDisplay.bottom-g_rcDisplay.top);
	}
}
#endif

VOID DoBltFrame(char *bgr, HWND hWnd)
{
	int height = (int)g_uVideoHeight;
	BITMAPINFOHEADER bmpInfo = {0};
	HDC         hDc = NULL;
	RECT		rc = {0};

	hDc = GetDC(hWnd);
	if(hDc != NULL)
	{
		GetWindowRect(hWnd, &rc);
		
		bmpInfo.biSize = sizeof(BITMAPINFOHEADER);
		bmpInfo.biWidth = g_uVideoWidth;
		bmpInfo.biHeight = -height;
		bmpInfo.biBitCount = g_uBitsPixel;
		bmpInfo.biPlanes = 1;
		bmpInfo.biCompression = BI_RGB;
		
		StretchDIBits(hDc, g_rcDisplay.left - rc.left, g_rcDisplay.top - rc.top, 
			g_rcDisplay.right-g_rcDisplay.left, 
			g_rcDisplay.bottom-g_rcDisplay.top, 
			0, 0, g_uVideoWidth, g_uVideoHeight, bgr, (LPBITMAPINFO)&bmpInfo, DIB_RGB_COLORS, SRCCOPY);		
		
		ReleaseDC(hWnd, hDc);
		hDc = NULL;
	}
}

DWORD WINAPI CaptureThreadProc(LPVOID lpParameter)
{
	LPBYTE rgb_buf = NULL;
	LPBYTE scale_buf = NULL;
	LPBYTE jpg_buf = NULL;
	UINT rgb_size = g_uVideoWidth * g_uVideoHeight * g_uBitsPixel / 8;
	UINT scale_size = g_uScreenWidth * g_uScreenHeight * g_uBitsPixel / 8;
	avi_t *avi = NULL;

	rgb_buf = (LPBYTE)malloc(rgb_size);
#if defined(ARM)
	if(g_pFrameBuffer)
	{
		scale_buf = (LPBYTE)malloc(scale_size);
		if(NULL == scale_buf)
			goto done;
	}
#endif
	if(NULL == rgb_buf)
		goto done;

	if (capStartCamera(g_uIndex) < 0)
		goto done;

	if(g_fIsCapture)
	{
		DWORD dwRtn[2] = {0};		
		UINT jpg_size = MAX_JPG_SIZE;

		jpg_buf = (LPBYTE)malloc(jpg_size);
		if(NULL == jpg_buf)
			goto done;
		
		avi = AVI_open_output_file(g_szCapFile);
		if(NULL == avi)
			goto done;

		AVI_set_video(avi, g_uVideoWidth, g_uVideoHeight, 15, "MJPG");
		AVI_set_audio(avi, 0, 44100, 16, 8000, WAVE_FORMAT_UNKNOWN);
		
		while(g_fIsStart && !g_fIsExit)
		{
			dwRtn[0] = dwRtn[1] = 0;
			
			if (0 == capGetPicture(0, rgb_buf, rgb_size, jpg_buf, jpg_size, dwRtn))
			{
				AVI_write_frame(avi, jpg_buf, dwRtn[1]);
				
#if defined(ARM)
				if(g_pFrameBuffer)
				{
					EnterCriticalSection(&g_csLock);
					scale(g_pScaler, rgb_buf, scale_buf);
					LeaveCriticalSection(&g_csLock);
					if(!g_fIsPauseDisplay)
						DoDrawFrame(scale_buf);
				}
				else
				{
					DoBltFrame(rgb_buf, g_hWnd);
					Sleep(10);
				}
#else
				DoBltFrame(rgb_buf, g_hWnd);
				Sleep(10);
#endif				
			}
			else
			{
				Sleep(10);
			}
		}
	}
	else
	{
		while(g_fIsStart && !g_fIsExit)
		{
			if(capGrabFrame(g_uIndex, rgb_buf, rgb_size) > 0)
			{				
#if defined(ARM)
				if(g_pFrameBuffer)
				{
					EnterCriticalSection(&g_csLock);
					scale(g_pScaler, rgb_buf, scale_buf);
					LeaveCriticalSection(&g_csLock);
					if(!g_fIsPauseDisplay)
						DoDrawFrame(scale_buf);
				}
				else
				{
					DoBltFrame(rgb_buf, g_hWnd);
					Sleep(10);
				}
#else
				DoBltFrame(rgb_buf, g_hWnd);
				Sleep(10);
#endif
			}
			else
			{
				Sleep(10);
			}
		}		
	}

done:
	capStopCamera(g_uIndex);
	SAFE_FREE(rgb_buf);
	SAFE_FREE(scale_buf);
	SAFE_FREE(jpg_buf);
	if(avi)
	{
		AVI_close(avi);
		avi = NULL;
	}

	return 0;
}

VOID DoAbout(HWND hWnd)
{
	int len = 0;
	TCHAR szText[MAX_PATH] = {0};
	len = capGetCurrentVersion(g_uIndex, (unsigned char *)szText, sizeof(szText));
	if (len > 0)
	{
		MessageBox(hWnd, szText, TEXT("Driver Version"), MB_OK | MB_TOPMOST | MB_ICONINFORMATION);
	}
}

VOID GetModulePath(LPTSTR path, LPCTSTR module)
{
	TCHAR* s;
	HANDLE Handle = NULL;
	if(module)
		Handle = GetModuleHandle(module);
	GetModuleFileName(Handle, path, MAX_PATH);
	s = _tcsrchr(path, '\\');
	if(s) s[1] = 0;
}

VOID DoSnapShot(HWND hWnd)
{
	int length = 0;
	int bufferLen = MAX_JPG_SIZE;
	PBYTE buffer = malloc(bufferLen);
	
	if(NULL == buffer)
		return;

	length = capGetLastJpeg(g_uIndex, buffer, bufferLen);
	if (length > 0)
	{
		HANDLE hFile = NULL;
		DWORD dwWritten = 0;
		TCHAR szPath[MAX_PATH] = {0};
		TCHAR szName[MAX_PATH] = {0};
		SYSTEMTIME st = {0};

		GetLocalTime(&st);
		GetModulePath(szPath, NULL);
		_stprintf(szName, TEXT("%s\\%d%02d%02d%02d%02d%02d.jpg"), szPath, 
			st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
		
		hFile = CreateFile(szName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if (hFile != INVALID_HANDLE_VALUE)
		{
			WriteFile(hFile, buffer, length, &dwWritten, NULL);
			CloseHandle(hFile);
			hFile = NULL;
		}		
	}
	
	SAFE_FREE(buffer);
}

VOID DoFullScreen(HWND hWnd, BOOL isFullScreen)
{
	CommandBar_Show(g_hMenuBar, !isFullScreen);
	SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
	AdjustDisplay(hWnd, isFullScreen);
	InvalidateRect(hWnd, NULL, TRUE);
	UpdateWindow(hWnd);
}

LRESULT CALLBACK MainWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	int fmt = -1;
	TCHAR szPath[MAX_PATH] = {0};

	switch(uMsg)
	{
	case WM_CREATE:	
		return 0;
#if defined(ARM)
	case WM_ENTERMENULOOP:
		if(g_pFrameBuffer)
		{
			g_fIsPauseDisplay = TRUE;
		}
		return 0;
	case WM_EXITMENULOOP:
		if(g_pFrameBuffer)
		{
			g_fIsPauseDisplay = FALSE;
		}
		return 0;
#endif
	case WM_LBUTTONDOWN:
		if(g_fIsFullScreen)
		{
			g_fIsFullScreen = FALSE;
			DoFullScreen(hWnd, FALSE);
		}
		return 0;
	case WM_COMMAND:
		switch(LOWORD(wParam))
		{
		case IDM_EXIT:
			SendMessage(hWnd, WM_CLOSE, 0, 0);
			break;
		case IDM_CAP_FILE:
			if(!g_fIsStart && GetFilePath(hWnd, szPath))
			{
				char szFile[MAX_PATH] = {0};
				memset(g_szCapFile, 0, sizeof(g_szCapFile));
				WideCharToMultiByte(CP_ACP, 0, szPath, wcslen(szPath), szFile, sizeof(szFile), NULL, NULL);
				sprintf(g_szCapFile, "%s.avi", szFile);
				if(strlen(g_szCapFile) > 0)
					g_fIsCapture = TRUE;
			}
			SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
			break;
		case IDM_SIZE_QVGA:
			fmt = GetVideoPalette(g_uBitsPixel);
			if(fmt < 0 || g_fIsStart)
				break;

			if (0 != capSetVideoFormat(g_uIndex, fmt, VIDEO_SIZE_SIF))
			{
				MessageBox(hWnd, TEXT("Set video format failed!"), TEXT("Error"), MB_OK | MB_ICONERROR);
			}
			else
			{
				g_uVideoWidth = 320;
				g_uVideoHeight = 240;
				AdjustDisplay(hWnd, g_fIsFullScreen);

				CheckMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_QVGA, MF_BYCOMMAND | MF_CHECKED);
				CheckMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_VGA, MF_BYCOMMAND | MF_UNCHECKED);
				
			}
			break;
		case IDM_SIZE_VGA:
			fmt = GetVideoPalette(g_uBitsPixel);
			if(fmt < 0 || g_fIsStart)
				break;
			
			if (0 != capSetVideoFormat(g_uIndex, fmt, VIDEO_SIZE_VGA))
			{
				MessageBox(hWnd, TEXT("Set video format failed!"), TEXT("Error"), MB_OK | MB_ICONERROR);
			}
			else
			{
				g_uVideoWidth = 640;
				g_uVideoHeight = 480;
				AdjustDisplay(hWnd, g_fIsFullScreen);

				CheckMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_VGA, MF_BYCOMMAND | MF_CHECKED);
				CheckMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_QVGA, MF_BYCOMMAND | MF_UNCHECKED);
				
			}
			break;
		case IDM_START:			
			if(!g_fIsStart)
			{
				g_fIsStart = TRUE;
#if defined(ARM)
				g_fIsPauseDisplay = FALSE;
#endif
				InvalidateRect(hWnd, NULL, TRUE);
				UpdateWindow(hWnd);
				g_hThread = CreateThread(NULL, 0, CaptureThreadProc, 0, 0, NULL);
				
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_START, MF_BYCOMMAND | MF_GRAYED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_CAP_FILE, MF_BYCOMMAND | MF_GRAYED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_QVGA, MF_BYCOMMAND | MF_GRAYED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_VGA, MF_BYCOMMAND | MF_GRAYED);
				
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_STOP, MF_BYCOMMAND | MF_ENABLED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SNAPSHOT, MF_BYCOMMAND | MF_ENABLED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_FULLSCREEN, MF_BYCOMMAND | MF_ENABLED);
				
			}
			break;
		case IDM_STOP:
			if(g_fIsStart)
			{
				DWORD dwCode = 0;
				g_fIsStart = FALSE;
				
				Sleep(500);
				if (GetExitCodeThread(g_hThread, &dwCode))
				{
					if (dwCode == STILL_ACTIVE)
					{
						TerminateThread(g_hThread, 0);
					}
					
					CloseHandle(g_hThread);
					g_hThread = NULL;
				}		

				InvalidateRect(hWnd, NULL, TRUE);
				UpdateWindow(hWnd);

				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_START, MF_BYCOMMAND | MF_ENABLED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_CAP_FILE, MF_BYCOMMAND | MF_ENABLED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_QVGA, MF_BYCOMMAND | MF_ENABLED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SIZE_VGA, MF_BYCOMMAND | MF_ENABLED);
				
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_STOP, MF_BYCOMMAND | MF_GRAYED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_SNAPSHOT, MF_BYCOMMAND | MF_GRAYED);
				EnableMenuItem(CommandBar_GetMenu(g_hMenuBar, 0), IDM_FULLSCREEN, MF_BYCOMMAND | MF_GRAYED);
			}
			break;
		case IDM_SNAPSHOT:
			if(g_fIsStart)
			{
				DoSnapShot(hWnd);
			}
			break;
		case IDM_FULLSCREEN:
			if(g_fIsStart)
			{
				g_fIsFullScreen = TRUE;
				DoFullScreen(hWnd, TRUE);
			}
			break;
		case IDM_ABOUT:
			if(!g_fIsStart)
				DoAbout(hWnd);
			break;		
		}
		return 0;
	case WM_CLOSE:
		g_fIsExit = TRUE;
		PostQuitMessage(0);
		return 0;
	default: break;
	}

	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

/* End of file */