获取一个窗口的截图

loverinmydream

我想要通过窗口句柄获取一个窗口的截图，这个窗口是一个外部程序的，只知道进程号，然后回显到当前正在运行的程序窗口上。
这些代码是我从https://learn.microsoft.com/en-us/windows/win32/gdi/capturing-an-image复制下来的，在147行GetDC(NULL)获取桌面窗口句柄，这样可以成功显示。
但是当我把GetDC()参数换成上面这种通过进程ID获取的窗口句柄时，显示都是黑屏的。我不知道是什么原因，求大佬解答

1. BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
   
2. {
   
3.         EnumWindowsArg* pArg = (EnumWindowsArg*)lParam;
   
4.         DWORD  dwProcessID = 0;
   
5.         // 通过窗口句柄取得进程ID
   
6.         ::GetWindowThreadProcessId(hwnd, &dwProcessID);
   
7.         if (dwProcessID == pArg->dwProcessID)
   
8.         {
   
9.                 pArg->hwndWindow = hwnd;
   
10.                 // 找到了返回FALSE
    
11.                 return FALSE;
    
12.         }
    
13.         // 没找到，继续找，返回TRUE
    
14.         return TRUE;
    
15. }
    
16. 
    
17. ///< 通过进程ID获取窗口句柄
    
18. HWND GetWindowHwndByPID(DWORD dwProcessID)
    
19. {
    
20.         HWND hwndRet = NULL;
    
21.         EnumWindowsArg ewa;
    
22.         ewa.dwProcessID = dwProcessID;
    
23.         ewa.hwndWindow = NULL;
    
24.         EnumWindows(EnumWindowsProc, (LPARAM)&ewa);
    
25.         if (ewa.hwndWindow)
    
26.         {
    
27.                 hwndRet = ewa.hwndWindow;
    
28.         }
    
29.         return hwndRet;
    
30. }

复制代码

1. // GDI_CapturingAnImage.cpp : Defines the entry point for the application.
   
2. //
   
3. 
   
4. #include "framework.h"
   
5. #include "GDI_CapturingAnImage.h"
   
6. #include "GetHWND.h"
   
7. 
   
8. #define MAX_LOADSTRING 100
   
9. 
   
10. // Global Variables:
    
11. HINSTANCE hInst;                                // current instance
    
12. WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
    
13. WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
    
14. 
    
15. // Forward declarations of functions included in this code module:
    
16. ATOM                MyRegisterClass(HINSTANCE hInstance);
    
17. BOOL                InitInstance(HINSTANCE, int);
    
18. LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
    
19. INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
    
20. 
    
21. int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
    
22.   _In_opt_ HINSTANCE hPrevInstance,
    
23.   _In_ LPWSTR    lpCmdLine,
    
24.   _In_ int       nCmdShow)
    
25. {
    
26.   UNREFERENCED_PARAMETER(hPrevInstance);
    
27.   UNREFERENCED_PARAMETER(lpCmdLine);
    
28. 
    
29.   // TODO: Place code here.
    
30. 
    
31.   // Initialize global strings
    
32.   LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    
33.   LoadStringW(hInstance, IDC_GDICAPTURINGANIMAGE, szWindowClass, MAX_LOADSTRING);
    
34.   MyRegisterClass(hInstance);
    
35. 
    
36.   // Perform application initialization:
    
37.   if (!InitInstance(hInstance, nCmdShow))
    
38.   {
    
39.     return FALSE;
    
40.   }
    
41. 
    
42.   HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_GDICAPTURINGANIMAGE));
    
43. 
    
44.   MSG msg;
    
45. 
    
46.   // Main message loop:
    
47.   while (GetMessage(&msg, nullptr, 0, 0))
    
48.   {
    
49.     if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
    
50.     {
    
51.       TranslateMessage(&msg);
    
52.       DispatchMessage(&msg);
    
53.     }
    
54.   }
    
55. 
    
56.   return (int)msg.wParam;
    
57. }
    
58. 
    
59. //
    
60. //  FUNCTION: MyRegisterClass()
    
61. //
    
62. //  PURPOSE: Registers the window class.
    
63. //
    
64. ATOM MyRegisterClass(HINSTANCE hInstance)
    
65. {
    
66.   WNDCLASSEXW wcex;
    
67. 
    
68.   wcex.cbSize = sizeof(WNDCLASSEX);
    
69. 
    
70.   wcex.style = CS_HREDRAW | CS_VREDRAW;
    
71.   wcex.lpfnWndProc = WndProc;
    
72.   wcex.cbClsExtra = 0;
    
73.   wcex.cbWndExtra = 0;
    
74.   wcex.hInstance = hInstance;
    
75.   wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_GDICAPTURINGANIMAGE));
    
76.   wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    
77.   wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    
78.   wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_GDICAPTURINGANIMAGE);
    
79.   wcex.lpszClassName = szWindowClass;
    
80.   wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    
81. 
    
82.   return RegisterClassExW(&wcex);
    
83. }
    
84. 
    
85. //
    
86. //   FUNCTION: InitInstance(HINSTANCE, int)
    
87. //
    
88. //   PURPOSE: Saves instance handle and creates main window
    
89. //
    
90. //   COMMENTS:
    
91. //
    
92. //        In this function, we save the instance handle in a global variable and
    
93. //        create and display the main program window.
    
94. //
    
95. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
    
96. {
    
97.   hInst = hInstance; // Store instance handle in our global variable
    
98. 
    
99.   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
    
100.     CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
     
101. 
     
102.   if (!hWnd)
     
103.   {
     
104.     return FALSE;
     
105.   }
     
106. 
     
107.   ShowWindow(hWnd, nCmdShow);
     
108.   UpdateWindow(hWnd);
     
109. 
     
110.   return TRUE;
     
111. }
     
112. 
     
113. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
     
114. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
     
115. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
     
116. // PARTICULAR PURPOSE.
     
117. //
     
118. // Copyright (c) Microsoft Corporation. All rights reserved
     
119. 
     
120. //
     
121. //   FUNCTION: CaptureAnImage(HWND hWnd)
     
122. //
     
123. //   PURPOSE: Captures a screenshot into a window ,and then saves it in a .bmp file.
     
124. //
     
125. //   COMMENTS:
     
126. //
     
127. //      Note: This function attempts to create a file called captureqwsx.bmp
     
128. //        
     
129. 
     
130. int CaptureAnImage(HWND hWnd)
     
131. {
     
132.   HDC hdcScreen;
     
133.   HDC hdcWindow;
     
134.   HDC hdcMemDC = NULL;
     
135.   HBITMAP hbmScreen = NULL;
     
136.   BITMAP bmpScreen;
     
137.   DWORD dwBytesWritten = 0;
     
138.   DWORD dwSizeofDIB = 0;
     
139.   HANDLE hFile = NULL;
     
140.   char* lpbitmap = NULL;
     
141.   HANDLE hDIB = NULL;
     
142.   DWORD dwBmpSize = 0;
     
143. 
     
144.   // Retrieve the handle to a display device context for the client
     
145.   // area of the window.
     
146.   // HWND nhdcScreen = GetWindowHwndByPID(27380);
     
147.   hdcScreen = GetDC(NULL); // source
     
148. 
     
149.   hdcWindow = GetDC(hWnd);  // destination
     
150. 
     
151.   // Create a compatible DC, which is used in a BitBlt from the window DC.
     
152.   hdcMemDC = CreateCompatibleDC(hdcWindow);
     
153. 
     
154.   if (!hdcMemDC)
     
155.   {
     
156.     MessageBox(hWnd, L"CreateCompatibleDC has failed", L"Failed", MB_OK);
     
157.     goto done;
     
158.   }
     
159. 
     
160.   // Get the client area for size calculation.
     
161.   RECT rcClient;
     
162.   GetClientRect(hWnd, &rcClient);
     
163. 
     
164.   // This is the best stretch mode.
     
165.   SetStretchBltMode(hdcWindow, HALFTONE);
     
166. 
     
167.   // The source DC is the entire screen, and the destination DC is the current window (HWND).
     
168.   if (!StretchBlt(hdcWindow,
     
169.     0, 0,
     
170.     rcClient.right, rcClient.bottom,
     
171.     hdcScreen,
     
172.     0, 0,
     
173.     GetSystemMetrics(SM_CXSCREEN),
     
174.     GetSystemMetrics(SM_CYSCREEN),
     
175.     SRCCOPY))
     
176.   {
     
177.     MessageBox(hWnd, L"StretchBlt has failed", L"Failed", MB_OK);
     
178.     goto done;
     
179.   }
     
180. 
     
181.   // Create a compatible bitmap from the Window DC.
     
182.   hbmScreen = CreateCompatibleBitmap(hdcWindow, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top);
     
183. 
     
184.   if (!hbmScreen)
     
185.   {
     
186.     MessageBox(hWnd, L"CreateCompatibleBitmap Failed", L"Failed", MB_OK);
     
187.     goto done;
     
188.   }
     
189. 
     
190.   // Select the compatible bitmap into the compatible memory DC.
     
191.   SelectObject(hdcMemDC, hbmScreen);
     
192. 
     
193.   // Bit block transfer into our compatible memory DC.
     
194.   if (!BitBlt(hdcMemDC,
     
195.     0, 0,
     
196.     rcClient.right - rcClient.left, rcClient.bottom - rcClient.top,
     
197.     hdcWindow,
     
198.     0, 0,
     
199.     SRCCOPY))
     
200.   {
     
201.     MessageBox(hWnd, L"BitBlt has failed", L"Failed", MB_OK);
     
202.     goto done;
     
203.   }
     
204. 
     
205.   // Get the BITMAP from the HBITMAP.
     
206.   GetObject(hbmScreen, sizeof(BITMAP), &bmpScreen);
     
207. 
     
208.   BITMAPFILEHEADER   bmfHeader;
     
209.   BITMAPINFOHEADER   bi;
     
210. 
     
211.   bi.biSize = sizeof(BITMAPINFOHEADER);
     
212.   bi.biWidth = bmpScreen.bmWidth;
     
213.   bi.biHeight = bmpScreen.bmHeight;
     
214.   bi.biPlanes = 1;
     
215.   bi.biBitCount = 32;
     
216.   bi.biCompression = BI_RGB;
     
217.   bi.biSizeImage = 0;
     
218.   bi.biXPelsPerMeter = 0;
     
219.   bi.biYPelsPerMeter = 0;
     
220.   bi.biClrUsed = 0;
     
221.   bi.biClrImportant = 0;
     
222. 
     
223.   dwBmpSize = ((bmpScreen.bmWidth * bi.biBitCount + 31) / 32) * 4 * bmpScreen.bmHeight;
     
224. 
     
225.   // Starting with 32-bit Windows, GlobalAlloc and LocalAlloc are implemented as wrapper functions that
     
226.   // call HeapAlloc using a handle to the process's default heap. Therefore, GlobalAlloc and LocalAlloc
     
227.   // have greater overhead than HeapAlloc.
     
228.   hDIB = GlobalAlloc(GHND, dwBmpSize);
     
229.   lpbitmap = (char*)GlobalLock(hDIB);
     
230. 
     
231.   // Gets the "bits" from the bitmap, and copies them into a buffer
     
232.   // that's pointed to by lpbitmap.
     
233.   GetDIBits(hdcWindow, hbmScreen, 0,
     
234.     (UINT)bmpScreen.bmHeight,
     
235.     lpbitmap,
     
236.     (BITMAPINFO*)&bi, DIB_RGB_COLORS);
     
237. 
     
238.   // A file is created, this is where we will save the screen capture.
     
239.   hFile = CreateFile(L"captureqwsx.bmp",
     
240.     GENERIC_WRITE,
     
241.     0,
     
242.     NULL,
     
243.     CREATE_ALWAYS,
     
244.     FILE_ATTRIBUTE_NORMAL, NULL);
     
245. 
     
246.   // Add the size of the headers to the size of the bitmap to get the total file size.
     
247.   dwSizeofDIB = dwBmpSize + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
     
248. 
     
249.   // Offset to where the actual bitmap bits start.
     
250.   bmfHeader.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER);
     
251. 
     
252.   // Size of the file.
     
253.   bmfHeader.bfSize = dwSizeofDIB;
     
254. 
     
255.   // bfType must always be BM for Bitmaps.
     
256.   bmfHeader.bfType = 0x4D42; // BM.
     
257. 
     
258.   WriteFile(hFile, (LPSTR)&bmfHeader, sizeof(BITMAPFILEHEADER), &dwBytesWritten, NULL);
     
259.   WriteFile(hFile, (LPSTR)&bi, sizeof(BITMAPINFOHEADER), &dwBytesWritten, NULL);
     
260.   WriteFile(hFile, (LPSTR)lpbitmap, dwBmpSize, &dwBytesWritten, NULL);
     
261. 
     
262.   // Unlock and Free the DIB from the heap.
     
263.   GlobalUnlock(hDIB);
     
264.   GlobalFree(hDIB);
     
265. 
     
266.   // Close the handle for the file that was created.
     
267.   CloseHandle(hFile);
     
268. 
     
269.   // Clean up.
     
270. done:
     
271.   DeleteObject(hbmScreen);
     
272.   DeleteObject(hdcMemDC);
     
273.   ReleaseDC(NULL, hdcScreen);
     
274.   ReleaseDC(hWnd, hdcWindow);
     
275. 
     
276.   return 0;
     
277. }
     
278. 
     
279. //
     
280. //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
     
281. //
     
282. //  PURPOSE: Processes messages for the main window.
     
283. //
     
284. //  WM_COMMAND  - process the application menu
     
285. //  WM_PAINT    - Paint the main window
     
286. //  WM_DESTROY  - post a quit message and return
     
287. //
     
288. //
     
289. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
     
290. {
     
291.   switch (message)
     
292.   {
     
293.   case WM_COMMAND:
     
294.   {
     
295.     int wmId = LOWORD(wParam);
     
296.     // Parse the menu selections:
     
297.     switch (wmId)
     
298.     {
     
299.     case IDM_ABOUT:
     
300.       DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
     
301.       break;
     
302.     case IDM_EXIT:
     
303.       DestroyWindow(hWnd);
     
304.       break;
     
305.     default:
     
306.       return DefWindowProc(hWnd, message, wParam, lParam);
     
307.     }
     
308.   }
     
309.   break;
     
310.   case WM_PAINT:
     
311.   {
     
312.     PAINTSTRUCT ps;
     
313.     HDC hdc = BeginPaint(hWnd, &ps);
     
314.     CaptureAnImage(hWnd);
     
315.     EndPaint(hWnd, &ps);
     
316.   }
     
317.   break;
     
318.   case WM_DESTROY:
     
319.     PostQuitMessage(0);
     
320.     break;
     
321.   default:
     
322.     return DefWindowProc(hWnd, message, wParam, lParam);
     
323.   }
     
324.   return 0;
     
325. }
     
326. 
     
327. // Message handler for about box.
     
328. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
     
329. {
     
330.   UNREFERENCED_PARAMETER(lParam);
     
331.   switch (message)
     
332.   {
     
333.   case WM_INITDIALOG:
     
334.     return (INT_PTR)TRUE;
     
335. 
     
336.   case WM_COMMAND:
     
337.     if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
     
338.     {
     
339.       EndDialog(hDlg, LOWORD(wParam));
     
340.       return (INT_PTR)TRUE;
     
341.     }
     
342.     break;
     
343.   }
     
344.   return (INT_PTR)FALSE;
     
345. }

复制代码

FishC

你遇到的问题是在将代码中的获取窗口句柄的函数`GetWindowHwndByPID`替换进程号获取窗口句柄代码时出现黑屏的情况。这是因为你使用的是外部程序的进程ID，而不是窗口句柄。

想要通过进程ID获取窗口句柄，你可以使用以下函数来实现：

1. HWND GetWindowHwndByPID(DWORD dwProcessID)
   
2. {
   
3.     HWND hwndRet = NULL;
   
4.     EnumWindows([&](HWND hWnd, LPARAM lParam) {
   
5.         DWORD pid = 0;
   
6.         GetWindowThreadProcessId(hWnd, &pid);
   
7.         if (pid == dwProcessID) {
   
8.             hwndRet = hWnd;
   
9.             return FALSE; // 找到了就返回FALSE停止枚举
   
10.         }
    
11.         return TRUE; // 没找到继续
    
12.     }, 0);
    
13. 
    
14.     return hwndRet;
    
15. }

复制代码

请注意这里我们使用了C++11中的lambda表达式来实现回调函数，以便在回调函数内部使用局部变量。

然后，你需要在`WndProc`中进行截图并回显到当前窗口。你可以修改`WM_PAINT`消息的处理部分，如下所示：

1. case WM_PAINT:
   
2. {
   
3.     PAINTSTRUCT ps;
   
4.     HDC hdc = BeginPaint(hWnd, &ps);
   
5.     HWND targetHwnd = GetWindowHwndByPID(外部程序的进程ID);
   
6.     if (targetHwnd != NULL) {
   
7.         CaptureAnImage(targetHwnd);
   
8.         // 将截图显示在当前窗口
   
9.         HBITMAP hBitmap = (HBITMAP)LoadImage(NULL, L"captureqwsx.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
   
10.         HDC hdcMem = CreateCompatibleDC(hdc);
    
11.         SelectObject(hdcMem, hBitmap);
    
12.         BITMAP bitmap;
    
13.         GetObject(hBitmap, sizeof(bitmap), &bitmap);
    
14.         BitBlt(hdc, 0, 0, bitmap.bmWidth, bitmap.bmHeight, hdcMem, 0, 0, SRCCOPY);
    
15.         DeleteDC(hdcMem);
    
16.         DeleteObject(hBitmap);
    
17.     }
    
18.     EndPaint(hWnd, &ps);
    
19.     break;
    
20. }

复制代码

这样，当`WM_PAINT`消息被触发时，会获取外部程序窗口的截图，并将截图显示在当前程序窗口上。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

某一个“天”

某一个“天”

厉害啊

某一个“天”

当你在使用 GetDC() 函数来捕获一个特定窗口的屏幕图像时，需要注意几个关键点。GetDC(NULL) 实际上获取的是整个屏幕的DC（设备上下文），而当你尝试对一个特定的窗口句柄调用 GetDC(hwnd) 时，你期望得到的是这个窗口的DC。

然而，仅仅使用 GetDC(hwnd) 可能不足以捕获一个窗口的内容，尤其是当窗口有自己的绘图逻辑（如使用DirectX、OpenGL或其他图形API）时。此外，如果窗口是透明的或者绘制在其上的内容是部分或全部透明的，你可能无法看到预期的内容。

下面是一些步骤和建议，帮助你成功捕获一个窗口的图像：

确保窗口存在并可见：
确保你捕获的窗口确实存在并且是可见的。你可以通过调用 IsWindowVisible() 来检查这一点。
使用 PrintWindow 函数：
PrintWindow 函数是一个更高级别的API，它专门用于捕获窗口的图像。这个函数会发送一个 WM_PRINT 消息到目标窗口，这通常会导致窗口按照打印机的方式渲染其内容。这通常比直接使用 GetDC 和位图操作更有效。
cpp
HWND hwnd = GetWindowHwndByPID(dwProcessID);  
if (hwnd && IsWindowVisible(hwnd)) {  
    RECT rc;  
    GetClientRect(hwnd, &rc);  
    HDC hdcScreen = GetDC(NULL);  
    HBITMAP hBitmap = CreateCompatibleBitmap(hdcScreen, rc.right - rc.left, rc.bottom - rc.top);  
    HDC hdcMem = CreateCompatibleDC(hdcScreen);  
    SelectObject(hdcMem, hBitmap);  
    PrintWindow(hwnd, hdcMem, PW_CLIENTONLY);  
    // 现在 hBitmap 包含了你想要的窗口图像  
    // ... 在这里将 hBitmap 绘制到另一个窗口或保存为文件 ...  
    // 清理资源  
    DeleteDC(hdcMem);  
    DeleteObject(hBitmap);  
    ReleaseDC(NULL, hdcScreen);  
}
检查窗口的绘制逻辑：
如果 PrintWindow 仍然不能捕获你想要的图像，可能是因为窗口使用了特定的绘制逻辑，这些逻辑在接收到 WM_PRINT 消息时不会按预期工作。在这种情况下，你可能需要更深入地了解窗口的绘制机制，并考虑使用其他方法（如钩子、API劫持等）来捕获图像。
权限问题：
在某些情况下，尝试捕获其他进程的窗口图像可能会受到操作系统安全性的限制。确保你的应用程序有足够的权限来执行此操作。
错误处理：
确保你的代码中有适当的错误处理机制，以处理任何可能发生的失败情况（如窗口不存在、无法获取DC等）。
资源清理：
在捕获图像后，确保清理所有分配的资源（如HDC、HBITMAP等），以防止资源泄漏。