开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
oshelper.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：12k
源码类别：

VC书籍

开发平台：

Visual C++

oshelper.cpp：源码内容
  1. // VirtualDub - Video processing and capture application
  2. // Copyright (C) 1998-2001 Avery Lee
  3. //
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. #include "VirtualDub.h"
  19. #include <stdlib.h>
  21. #include <windows.h>
  22. #include <shellapi.h>
  23. #include "oshelper.h"
  25. void Draw3DRect(HDC hDC, LONG x, LONG y, LONG dx, LONG dy, BOOL inverted) {
  26. HPEN hPenOld;
  28. hPenOld = (HPEN)SelectObject(hDC, GetStockObject(inverted ? WHITE_PEN : BLACK_PEN));
  29. MoveToEx(hDC, x, y+dy-1, NULL);
  30. LineTo(hDC, x+dx-1, y+dy-1);
  31. LineTo(hDC, x+dx-1, y);
  32. DeleteObject(SelectObject(hDC, GetStockObject(inverted ? BLACK_PEN : WHITE_PEN)));
  33. MoveToEx(hDC, x, y+dy-1, NULL);
  34. LineTo(hDC, x, y);
  35. LineTo(hDC, x+dx-1, y);
  36. DeleteObject(SelectObject(hDC, hPenOld));
  37. }
  39. // We follow MAME32's lead and put our keys in:
  40. //
  41. // HKEY_CURRENT_USERSoftwareFreewareVirtualDub
  43. HKEY OpenConfigKey(const char *szKeyName) {
  44. char temp[MAX_PATH]="Software\Freeware\VirtualDub";
  45. HKEY hkey;
  47. if (szKeyName) {
  48. strcat(temp, "\");
  49. strcat(temp, szKeyName);
  50. }
  52. return RegOpenKeyEx(HKEY_CURRENT_USER, temp, 0, KEY_ALL_ACCESS, &hkey)==ERROR_SUCCESS
  53. ? hkey
  54. : NULL;
  55. }
  57. HKEY CreateConfigKey(const char *szKeyName) {
  58. char temp[MAX_PATH]="Software\Freeware\VirtualDub";
  59. HKEY hkey;
  60. DWORD dwDisposition;
  62. if (szKeyName) {
  63. strcat(temp, "\");
  64. strcat(temp, szKeyName);
  65. }
  67. return RegCreateKeyEx(HKEY_CURRENT_USER, temp, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDisposition)==ERROR_SUCCESS
  68. ? hkey
  69. : NULL;
  70. }
  72. BOOL DeleteConfigValue(const char *szKeyName, const char *szValueName) {
  73. HKEY hkey;
  74. BOOL success;
  76. if (!(hkey = OpenConfigKey(szKeyName)))
  77. return FALSE;
  79. success = (RegDeleteValue(hkey, szValueName) == ERROR_SUCCESS);
  81. RegCloseKey(hkey);
  83. return success;
  84. }
  86. BOOL QueryConfigString(const char *szKeyName, const char *szValueName, char *lpBuffer, int cbBuffer) {
  87. HKEY hkey;
  88. BOOL success;
  89. DWORD type;
  91. if (!(hkey = OpenConfigKey(szKeyName)))
  92. return FALSE;
  94. success = (ERROR_SUCCESS == RegQueryValueEx(hkey, szValueName, 0, &type, (LPBYTE)lpBuffer, (LPDWORD)&cbBuffer));
  96. RegCloseKey(hkey);
  98. return success;
  99. }
  101. DWORD QueryConfigBinary(const char *szKeyName, const char *szValueName, char *lpBuffer, int cbBuffer) {
  102. HKEY hkey;
  103. BOOL success;
  104. DWORD type;
  105. DWORD size = cbBuffer;
  107. if (!(hkey = OpenConfigKey(szKeyName)))
  108. return 0;
  110. success = (ERROR_SUCCESS == RegQueryValueEx(hkey, szValueName, 0, &type, (LPBYTE)lpBuffer, (LPDWORD)&size));
  112. RegCloseKey(hkey);
  114. return success ? size : 0;
  115. }
  117. BOOL QueryConfigDword(const char *szKeyName, const char *szValueName, DWORD *lpdwData) {
  118. HKEY hkey;
  119. BOOL success;
  120. DWORD type;
  121. DWORD size = sizeof(DWORD);
  123. if (!(hkey = OpenConfigKey(szKeyName)))
  124. return 0;
  126. success = (ERROR_SUCCESS == RegQueryValueEx(hkey, szValueName, 0, &type, (LPBYTE)lpdwData, (LPDWORD)&size));
  128. RegCloseKey(hkey);
  130. return success;
  131. }
  133. BOOL SetConfigString(const char *szKeyName, const char *szValueName, const char *lpBuffer) {
  134. HKEY hkey;
  135. BOOL success;
  137. if (!(hkey = CreateConfigKey(szKeyName)))
  138. return FALSE;
  140. success = (ERROR_SUCCESS == RegSetValueEx(hkey, szValueName, 0, REG_SZ, (LPBYTE)lpBuffer, strlen(lpBuffer)+1));
  142. RegCloseKey(hkey);
  144. return success;
  145. }
  147. BOOL SetConfigBinary(const char *szKeyName, const char *szValueName, const char *lpBuffer, int cbBuffer) {
  148. HKEY hkey;
  149. BOOL success;
  151. if (!(hkey = CreateConfigKey(szKeyName)))
  152. return FALSE;
  154. success = (ERROR_SUCCESS == RegSetValueEx(hkey, szValueName, 0, REG_BINARY, (LPBYTE)lpBuffer, cbBuffer));
  156. RegCloseKey(hkey);
  158. return success;
  159. }
  161. BOOL SetConfigDword(const char *szKeyName, const char *szValueName, DWORD dwData) {
  162. HKEY hkey;
  163. BOOL success;
  165. if (!(hkey = CreateConfigKey(szKeyName)))
  166. return FALSE;
  168. success = (ERROR_SUCCESS == RegSetValueEx(hkey, szValueName, 0, REG_DWORD, (LPBYTE)&dwData, sizeof(DWORD)));
  170. RegCloseKey(hkey);
  172. return success;
  173. }
  175. ///////////////////////////////////////////////////////////////////////////
  176. //
  177. // help support
  178. //
  179. ///////////////////////////////////////////////////////////////////////////
  181. static char g_szHelpPath[MAX_PATH]="VirtualD.hlp";
  183. void HelpSetPath() {
  184. char szPath[MAX_PATH];
  185. char *lpFilePart;
  186. char *ext = NULL;
  188. if (GetModuleFileName(NULL, szPath, sizeof szPath))
  189. if (GetFullPathName(szPath, sizeof g_szHelpPath, g_szHelpPath, &lpFilePart))
  190. strcpy(lpFilePart,"VirtualD.hlp");
  191. }
  193. const char *HelpGetPath() {
  194. return g_szHelpPath;
  195. }
  197. void HelpShowHelp(HWND hwnd) {
  198. WinHelp(hwnd, g_szHelpPath, HELP_FINDER, 0);
  199. }
  201. void HelpContext(HWND hwnd, DWORD helpID) {
  202. WinHelp(hwnd, g_szHelpPath, HELP_CONTEXT, helpID);
  203. }
  205. void HelpPopup(HWND hwnd, DWORD helpID) {
  206. WinHelp(hwnd, g_szHelpPath, HELP_CONTEXTPOPUP, helpID);
  207. }
  209. void HelpPopupByID(HWND hwnd, DWORD ctrlID, const DWORD *lookup) {
  210. while(lookup[0]) {
  211. if (lookup[0] == ctrlID)
  212. HelpPopup(hwnd, lookup[1]);
  214. lookup+=2;
  215. }
  216. }
  219. ///////////////////////////////////////////////////////////////////////////
  220. //
  221. // disk free space
  222. //
  223. ///////////////////////////////////////////////////////////////////////////
  225. static HINSTANCE g_hInstKernel32 = NULL;
  226. static BOOL (__stdcall *g_fpGetDiskFreeSpaceEx)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER) = NULL;
  227. static bool g_triedGetDiskFreeSpaceEx = false;
  229. __int64 MyGetDiskFreeSpace(const char *lpszRoot) {
  230. __int64 client_free, total_space, free_space;
  231. DWORD dwSectorsPerCluster, dwBytesPerSector, dwFreeClusters, dwTotalClusters;
  232. char tmp[MAX_PATH];
  234. if (!g_hInstKernel32 && !(g_hInstKernel32 = LoadLibrary("kernel32.dll")))
  235. return -1;
  237. if (!g_triedGetDiskFreeSpaceEx) {
  238. g_fpGetDiskFreeSpaceEx = (BOOL (__stdcall *)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER))GetProcAddress(g_hInstKernel32, "GetDiskFreeSpaceExA");
  239. g_triedGetDiskFreeSpaceEx = true;
  240. }
  242. lpszRoot = SplitPathRoot(tmp, lpszRoot);
  244. if (g_fpGetDiskFreeSpaceEx) {
  245. return g_fpGetDiskFreeSpaceEx(lpszRoot, (PULARGE_INTEGER)&client_free, (PULARGE_INTEGER)&total_space, (PULARGE_INTEGER)&free_space)
  246. ? free_space
  247. : -1;
  248. } else {
  249. return GetDiskFreeSpace(lpszRoot, &dwSectorsPerCluster, &dwBytesPerSector, &dwFreeClusters, &dwTotalClusters)
  250. ? dwFreeClusters * dwSectorsPerCluster * dwBytesPerSector
  251. : -1;
  252. }
  253. }
  256. const char *SplitPathName(const char *path) {
  257. const char *s = path;
  259. while(*s) ++s;
  261. while(s>path && s[-1]!='\' && s[-1]!=':')
  262. --s;
  264. return s;
  265. }
  267. const char *SplitPathExt(const char *path) {
  268. const char *s = path;
  269. const char *tail;
  271. while(*s) ++s;
  273. tail = s;
  275. while(s>path && s[-1]!='\' && s[-1]!=':') {
  276. if (s[-1]=='.')
  277. return s-1;
  279. --s;
  280. }
  282. return tail;
  283. }
  285. char *MergePath(char *path, const char *fn) {
  286. char *slash=NULL, *colon=NULL;
  287. char *s = path;
  289. if (!*s) {
  290. strcpy(path, fn);
  291. return path;
  292. }
  294. while(*s)
  295. ++s;
  297. if (s[-1]!='\' && s[-1]!=':')
  298. *s++ = '\';
  300. strcpy(s, fn);
  302. return path;
  303. }
  305. char *SplitPathRoot(char *dst, const char *path) {
  307. if (!path)
  308. return NULL;
  310. // C:
  312. if (isalpha(path[0]) && path[1]==':') {
  313. dst[0] = path[0];
  314. dst[1] = ':';
  315. dst[2] = '\';
  316. dst[3] = 0;
  318. return dst;
  319. }
  321. // UNC path?
  323. if (path[0] == '\' && path[1] == '\') {
  324. const char *s = path+2;
  325. char *t = dst;
  327. *t++ = '\';
  328. *t++ = '\';
  330. while(*s && *s != '\')
  331. *t++ = *s++;
  333. if (*s)
  334. *t++ = *s++;
  336. while(*s && *s != '\')
  337. *t++ = *s++;
  339. *t++ = '\';
  340. *t = 0;
  342. return dst;
  343. }
  345. return NULL;
  346. }
  348. bool IsFilenameOnFATVolume(const char *pszFilename) {
  349. char szFileRoot[MAX_PATH];
  350. DWORD dwMaxComponentLength;
  351. DWORD dwFSFlags;
  352. char szFilesystem[MAX_PATH];
  354. if (!GetVolumeInformation(SplitPathRoot(szFileRoot, pszFilename),
  355. NULL, 0, // Volume name buffer
  356. NULL, // Serial number buffer
  357. &dwMaxComponentLength,
  358. &dwFSFlags,
  359. szFilesystem,
  360. sizeof szFilesystem))
  361. return false;
  363. return !strnicmp(szFilesystem, "FAT", 3);
  364. }
  366. ///////////////////////////////////////////////////////////////////////////
  368. void LaunchURL(const char *pURL) {
  369. ShellExecute(NULL, "open", pURL, NULL, NULL, SW_SHOWNORMAL);
  370. }
  372. ///////////////////////////////////////////////////////////////////////////
  374. bool EnableCPUTracking() {
  375. HKEY hOpen;
  376. DWORD cbData;
  377. DWORD dwType;
  378. LPBYTE pByte;
  379. DWORD rc;
  381. bool fSuccess = true;
  383.     if ( (rc = RegOpenKeyEx(HKEY_DYN_DATA,"PerfStats\StartStat", 0,
  384. KEY_READ, &hOpen)) == ERROR_SUCCESS) {
  386. // query to get data size
  387. if ( (rc = RegQueryValueEx(hOpen,"KERNEL\CPUUsage",NULL,&dwType,
  388. NULL, &cbData )) == ERROR_SUCCESS) {
  390. pByte = (LPBYTE)allocmem(cbData);
  392. rc = RegQueryValueEx(hOpen,"KERNEL\CPUUsage",NULL,&dwType, pByte,
  393.                               &cbData );
  395. freemem(pByte);
  396. } else
  397. fSuccess = false;
  399. RegCloseKey(hOpen);
  400. } else
  401. fSuccess = false;
  403. return fSuccess;
  404. }
  406. bool DisableCPUTracking() {
  407. HKEY hOpen;
  408. DWORD cbData;
  409. DWORD dwType;
  410. LPBYTE pByte;
  411. DWORD rc;
  413. bool fSuccess = true;
  415.     if ( (rc = RegOpenKeyEx(HKEY_DYN_DATA,"PerfStats\StopStat", 0,
  416. KEY_READ, &hOpen)) == ERROR_SUCCESS) {
  418. // query to get data size
  419. if ( (rc = RegQueryValueEx(hOpen,"KERNEL\CPUUsage",NULL,&dwType,
  420. NULL, &cbData )) == ERROR_SUCCESS) {
  422. pByte = (LPBYTE)allocmem(cbData);
  424. rc = RegQueryValueEx(hOpen,"KERNEL\CPUUsage",NULL,&dwType, pByte,
  425.                               &cbData );
  427. freemem(pByte);
  428. } else
  429. fSuccess = false;
  431. RegCloseKey(hOpen);
  432. } else
  433. fSuccess = false;
  435. return fSuccess;
  436. }
  438. CPUUsageReader::CPUUsageReader() {
  439. FILETIME ftCreate, ftExit;
  441. hkeyKernelCPU = NULL;
  442. fNTMethod = false;
  444. if (GetProcessTimes(GetCurrentProcess(), &ftCreate, &ftExit, (FILETIME *)&kt_last, (FILETIME *)&ut_last)) {
  446. // Using Windows NT/2000 method
  447. GetSystemTimeAsFileTime((FILETIME *)&st_last);
  449. fNTMethod = true;
  451. } else {
  453. // Using Windows 95/98 method
  455. HKEY hkey;
  457. if (EnableCPUTracking()) {
  459. if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_DYN_DATA, "PerfStats\StatData", 0, KEY_READ, &hkey)) {
  460. hkeyKernelCPU = hkey;
  461. } else
  462. DisableCPUTracking();
  463. }
  464. }
  465. }
  467. CPUUsageReader::~CPUUsageReader() {
  468. if (hkeyKernelCPU) {
  469. RegCloseKey(hkeyKernelCPU);
  470. DisableCPUTracking();
  471. }
  472. }
  474. int CPUUsageReader::read() {
  476. if (hkeyKernelCPU) {
  477. DWORD type;
  478. DWORD dwUsage;
  479. DWORD size = sizeof dwUsage;
  481. if (ERROR_SUCCESS == RegQueryValueEx(hkeyKernelCPU, "KERNEL\CPUUsage", 0, &type, (LPBYTE)&dwUsage, (LPDWORD)&size))
  482. return (int)dwUsage;
  484. return -1;
  485. } else if (fNTMethod) {
  486. FILETIME ftCreate, ftExit;
  487. unsigned __int64 kt, st, ut;
  488. int cpu;
  490. GetProcessTimes(GetCurrentProcess(), &ftCreate, &ftExit, (FILETIME *)&kt, (FILETIME *)&ut);
  491. GetSystemTimeAsFileTime((FILETIME *)&st);
  493. if (st == st_last)
  494. return 100;
  495. else
  496. cpu = (int)((100 * (kt + ut - kt_last - ut_last) + (st - st_last)/2) / (st - st_last));
  498. kt_last = kt;
  499. ut_last = ut;
  500. st_last = st;
  502. return cpu;
  503. }
  505. return -1;
  506. }