webrtc m74 desktop capture 代码分析:
\webrtc\modules\desktop_capture\window_capturer_win.cc
/*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <assert.h>
#include <memory>
#include "modules/desktop_capture/desktop_capturer.h"
#include "modules/desktop_capture/desktop_frame_win.h"
#include "modules/desktop_capture/win/screen_capture_utils.h"
#include "modules/desktop_capture/win/window_capture_utils.h"
#include "modules/desktop_capture/window_finder_win.h"
#include "rtc_base/checks.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/logging.h"
#include "rtc_base/string_utils.h"
#include "rtc_base/trace_event.h"
#include "rtc_base/win32.h"
namespace webrtc {
namespace {
BOOL CALLBACK WindowsEnumerationHandler(HWND hwnd, LPARAM param) {
DesktopCapturer::SourceList* list =
reinterpret_cast<DesktopCapturer::SourceList*>(param);
// Skip windows that are invisible, minimized, have no title, or are owned,
// unless they have the app window style set.
int len = GetWindowTextLength(hwnd);
HWND owner = GetWindow(hwnd, GW_OWNER);
LONG exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
if (len == 0 || IsIconic(hwnd) || !IsWindowVisible(hwnd) ||
(owner && !(exstyle & WS_EX_APPWINDOW))) {
return TRUE;
}
// Skip unresponsive windows. Set timout with 50ms, in case system is under
// heavy load, the check can wait longer but wont' be too long to delay the
// the enumeration.
const UINT uTimeout = 50; // ms
if (!SendMessageTimeout(hwnd, WM_NULL, 0, 0, SMTO_ABORTIFHUNG, uTimeout,
nullptr)) {
return TRUE;
}
// Skip the Program Manager window and the Start button.
const size_t kClassLength = 256;
WCHAR class_name[kClassLength];
const int class_name_length = GetClassName(hwnd, class_name, kClassLength);
RTC_DCHECK(class_name_length)
<< "Error retrieving the application's class name";
// Skip Program Manager window and the Start button. This is the same logic
// that's used in Win32WindowPicker in libjingle. Consider filtering other
// windows as well (e.g. toolbars).
if (wcscmp(class_name, L"Progman") == 0 || wcscmp(class_name, L"Button") == 0)
return TRUE;
// Windows 8 introduced a "Modern App" identified by their class name being
// either ApplicationFrameWindow or windows.UI.Core.coreWindow. The
// associated windows cannot be captured, so we skip them.
// http://crbug.com/526883.
if (rtc::IsWindows8OrLater() &&
(wcscmp(class_name, L"ApplicationFrameWindow") == 0 ||
wcscmp(class_name, L"Windows.UI.Core.CoreWindow") == 0)) {
return TRUE;
}
DesktopCapturer::Source window;
window.id = reinterpret_cast<WindowId>(hwnd);
const size_t kTitleLength = 500;
WCHAR window_title[kTitleLength];
// Truncate the title if it's longer than kTitleLength.
GetWindowText(hwnd, window_title, kTitleLength);
window.title = rtc::ToUtf8(window_title);
// Skip windows when we failed to convert the title or it is empty.
if (window.title.empty())
return TRUE;
list->push_back(window);
return TRUE;
}
// Retrieves the rectangle of the window rect which is drawable by either OS or
// the owner application. The returned DesktopRect is in system coordinates.
// This function returns false if native APIs fail.
//
// When |window| is maximized, its borders and shadow effect will be ignored by
// OS and leave black. So we prefer to use GetCroppedWindowRect() when capturing
// its content to avoid the black area in the final DesktopFrame. But when the
// window is in normal mode, borders and shadow should be included.
bool GetWindowDrawableRect(HWND window,
DesktopRect* drawable_rect,
DesktopRect* original_rect) {
if (!GetWindowRect(window, original_rect)) {
return false;
}
bool is_maximized = false;
if (!IsWindowMaximized(window, &is_maximized)) {
return false;
}
if (is_maximized) {
return GetCroppedWindowRect(window, drawable_rect,
/* original_rect */ nullptr);
}
*drawable_rect = *original_rect;
return true;
}
class WindowCapturerWin : public DesktopCapturer {
public:
WindowCapturerWin();
~WindowCapturerWin() override;
// DesktopCapturer interface.
void Start(Callback* callback) override;
void CaptureFrame() override;
bool GetSourceList(SourceList* sources) override;
bool SelectSource(SourceId id) override;
bool FocusOnSelectedSource() override;
bool IsOccluded(const DesktopVector& pos) override;
private:
Callback* callback_ = nullptr;
// HWND and HDC for the currently selected window or nullptr if window is not
// selected.
HWND window_ = nullptr;
DesktopSize previous_size_;
WindowCaptureHelperWin window_capture_helper_;
// This map is used to avoid flickering for the case when SelectWindow() calls
// are interleaved with Capture() calls.
std::map<HWND, DesktopSize> window_size_map_;
WindowFinderWin window_finder_;
RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerWin);
};
WindowCapturerWin::WindowCapturerWin() {}
WindowCapturerWin::~WindowCapturerWin() {}
bool WindowCapturerWin::GetSourceList(SourceList* sources) {
SourceList result;
LPARAM param = reinterpret_cast<LPARAM>(&result);
// EnumWindows only enumerates root windows.
if (!EnumWindows(&WindowsEnumerationHandler, param))
return false;
for (auto it = result.begin(); it != result.end();) {
if (!window_capture_helper_.IsWindowOnCurrentDesktop(
reinterpret_cast<HWND>(it->id))) {
it = result.erase(it);
} else {
++it;
}
}
sources->swap(result);
std::map<HWND, DesktopSize> new_map;
for (const auto& item : *sources) {
HWND hwnd = reinterpret_cast<HWND>(item.id);
new_map[hwnd] = window_size_map_[hwnd];
}
window_size_map_.swap(new_map);
return true;
}
bool WindowCapturerWin::SelectSource(SourceId id) {
HWND window = reinterpret_cast<HWND>(id);
if (!IsWindow(window) || !IsWindowVisible(window) || IsIconic(window))
return false;
window_ = window;
// When a window is not in the map, window_size_map_[window] will create an
// item with DesktopSize (0, 0).
previous_size_ = window_size_map_[window];
return true;
}
bool WindowCapturerWin::FocusOnSelectedSource() {
if (!window_)
return false;
if (!IsWindow(window_) || !IsWindowVisible(window_) || IsIconic(window_))
return false;
return BringWindowToTop(window_) != FALSE &&
SetForegroundWindow(window_) != FALSE;
}
bool WindowCapturerWin::IsOccluded(const DesktopVector& pos) {
DesktopVector sys_pos = pos.add(GetFullscreenRect().top_left());
return reinterpret_cast<HWND>(window_finder_.GetWindowUnderPoint(sys_pos)) !=
window_;
}
void WindowCapturerWin::Start(Callback* callback) {
assert(!callback_);
assert(callback);
callback_ = callback;
}
void WindowCapturerWin::CaptureFrame() {
TRACE_EVENT0("webrtc", "WindowCapturerWin::CaptureFrame");
if (!window_) {
RTC_LOG(LS_ERROR) << "Window hasn't been selected: " << GetLastError();
callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
return;
}
// Stop capturing if the window has been closed.
if (!IsWindow(window_)) {
RTC_LOG(LS_ERROR) << "target window has been closed";
callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
return;
}
DesktopRect cropped_rect;
DesktopRect original_rect;
if (!GetWindowDrawableRect(window_, &cropped_rect, &original_rect)) {
RTC_LOG(LS_WARNING) << "Failed to get drawable window area: "
<< GetLastError();
callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
return;
}
// Return a 1x1 black frame if the window is minimized or invisible on current
// desktop, to match behavior on mace. Window can be temporarily invisible
// during the transition of full screen mode on/off.
if (original_rect.is_empty() ||
!window_capture_helper_.IsWindowVisibleOnCurrentDesktop(window_)) {
std::unique_ptr<DesktopFrame> frame(
new BasicDesktopFrame(DesktopSize(1, 1)));
previous_size_ = frame->size();
window_size_map_[window_] = previous_size_;
callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
return;
}
HDC window_dc = GetWindowDC(window_);
if (!window_dc) {
RTC_LOG(LS_WARNING) << "Failed to get window DC: " << GetLastError();
callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
return;
}
DesktopSize window_dc_size;
if (GetDcSize(window_dc, &window_dc_size)) {
// The |window_dc_size| is used to detect the scaling of the original
// window. If the application does not support high-DPI settings, it will
// be scaled by Windows according to the scaling setting.
// https://www.google.com/search?q=windows+scaling+settings&ie=UTF-8
// So the size of the |window_dc|, i.e. the bitmap we can retrieve from
// PrintWindow() or BitBlt() function, will be smaller than
// |original_rect| and |cropped_rect|. Part of the captured desktop frame
// will be black. See
// bug https://bugs.chromium.org/p/webrtc/issues/detail?id=8112 for
// details.
// If |window_dc_size| is smaller than |window_rect|, let's resize both
// |original_rect| and |cropped_rect| according to the scaling factor.
const double vertical_scale =
static_cast<double>(window_dc_size.width()) / original_rect.width();
const double horizontal_scale =
static_cast<double>(window_dc_size.height()) / original_rect.height();
original_rect.Scale(vertical_scale, horizontal_scale);
cropped_rect.Scale(vertical_scale, horizontal_scale);
}
std::unique_ptr<DesktopFrameWin> frame(
DesktopFrameWin::Create(cropped_rect.size(), nullptr, window_dc));
if (!frame.get()) {
RTC_LOG(LS_WARNING) << "Failed to create frame.";
ReleaseDC(window_, window_dc);
callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
return;
}
HDC mem_dc = CreateCompatibleDC(window_dc);
HGDIOBJ previous_object = SelectObject(mem_dc, frame->bitmap());
BOOL result = FALSE;
// When desktop composition (Aero) is enabled each window is rendered to a
// private buffer allowing BitBlt() to get the window content even if the
// window is occluded. PrintWindow() is slower but lets rendering the window
// contents to an off-screen device context when Aero is not available.
// PrintWindow() is not supported by some applications.
//
// If Aero is enabled, we prefer BitBlt() because it's faster and avoids
// window flickering. Otherwise, we prefer PrintWindow() because BitBlt() may
// render occluding windows on top of the desired window.
//
// When composition is enabled the DC returned by GetWindowDC() doesn't always
// have window frame rendered correctly. Windows renders it only once and then
// caches the result between captures. We hack it around by calling
// PrintWindow() whenever window size changes, including the first time of
// capturing - it somehow affects what we get from BitBlt() on the subsequent
// captures.
if (!window_capture_helper_.IsAeroEnabled() ||
!previous_size_.equals(frame->size())) {
result = PrintWindow(window_, mem_dc, 0);
}
// Aero is enabled or PrintWindow() failed, use BitBlt.
if (!result) {
result = BitBlt(mem_dc, 0, 0, frame->size().width(), frame->size().height(),
window_dc, cropped_rect.left() - original_rect.left(),
cropped_rect.top() - original_rect.top(), SRCCOPY);
}
SelectObject(mem_dc, previous_object);
DeleteDC(mem_dc);
ReleaseDC(window_, window_dc);
previous_size_ = frame->size();
window_size_map_[window_] = previous_size_;
frame->mutable_updated_region()->SetRect(
DesktopRect::MakeSize(frame->size()));
frame->set_top_left(
cropped_rect.top_left().subtract(GetFullscreenRect().top_left()));
if (result) {
callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
} else {
RTC_LOG(LS_ERROR) << "Both PrintWindow() and BitBlt() failed.";
callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
}
}
} // namespace
// static
std::unique_ptr<DesktopCapturer> DesktopCapturer::CreateRawWindowCapturer(
const DesktopCaptureOptions& options) {
return std::unique_ptr<DesktopCapturer>(new WindowCapturerWin());
}
} // namespace webrtc
其中,无论是 window or screen 模式,每次采集都会调用 WindowCapturerWin::CaptureFrame() 接口,
此接口内部会创建一个 frame 对象,在该对象的构造函数中会创建一个DIB 位图(因为是DIB而不是DDB,所以 位图与DC设备无关联,后面需要手动绑定到某个DC上):
// 创建 frame 对象
std::unique_ptr<DesktopFrameWin> frame(
DesktopFrameWin::Create(cropped_rect.size(), nullptr, window_dc));
if (!frame.get()) {
RTC_LOG(LS_WARNING) << "Failed to create frame.";
ReleaseDC(window_, window_dc);
callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
return;
}
此处着重说一下构造frame用到的接口:DesktopFrameWin::Create
源码来自\webrtc\modules\desktop_capture\desktop_frame_win.cc中
// \webrtc\modules\desktop_capture\desktop_frame_win.cc
// static
std::unique_ptr<DesktopFrameWin> DesktopFrameWin::Create(
DesktopSize size,
SharedMemoryFactory* shared_memory_factory,
HDC hdc) {
int bytes_per_row = size.width() * kBytesPerPixel;
int buffer_size = bytes_per_row * size.height();
// Describe a device independent bitmap (DIB) that is the size of the desktop.
BITMAPINFO bmi = {};
bmi.bmiHeader.biHeight = -size.height();
bmi.bmiHeader.biWidth = size.width();
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = DesktopFrameWin::kBytesPerPixel * 8;
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biSizeImage = bytes_per_row * size.height();
std::unique_ptr<SharedMemory> shared_memory;
HANDLE section_handle = nullptr;
if (shared_memory_factory) {
shared_memory = shared_memory_factory->CreateSharedMemory(buffer_size);
section_handle = shared_memory->handle();
}
void* data = nullptr;
HBITMAP bitmap =
CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, &data, section_handle, 0);
if (!bitmap) {
RTC_LOG(LS_WARNING) << "Failed to allocate new window frame "
<< GetLastError();
return nullptr;
}
return std::unique_ptr<DesktopFrameWin>(
new DesktopFrameWin(size, bytes_per_row, reinterpret_cast<uint8_t*>(data),
std::move(shared_memory), bitmap));
}
CreateDIBSection 函数创建应用程序可以直接写入的、与设备无关的位图(DIB)。该函数返回一个位图句柄。
HBITMAP CreateDIBSection(
HDC hdc,
const BITMAPINFO *pbmi,
UINT usage,
VOID **ppvBits,
HANDLE hSection,
DWORD offset
);
函数会根据位图结构信息(pbmi)分配内存空间,你不用为它分配内存,这块内存也不需要你释放,系统会自己释放的。系统为设备独立位图分配内存。如果在之后调用DeleteObject来删除设备独立位图,系统自动关闭内句柄。
上面DesktopFrameWin::Create其实已经指定了位图格式,这也决定了webrtc 最终采集的数据格式:
bmi.bmiHeader.biBitCount = DesktopFrameWin::kBytesPerPixel * 8;
其中 kBytesPerPixel 来自于DesktopFrameWin的基类DesktopFrame的 静态常量成员变量:
// DesktopFrame objects always hold RGBA data.
static const int kBytesPerPixel = 4;
然后把 frame 的位图绑定到窗口兼容DC上:
HDC mem_dc = CreateCompatibleDC(window_dc);
HGDIOBJ previous_object = SelectObject(mem_dc, frame->bitmap());
BOOL result = FALSE;
之后的流程逻辑应该很好猜,就是将窗口的图像拷贝到 mem_dc 中,这样就相当于将窗口图像数据拷贝到 frame中,最后从frame中取出位图数据。
但是,后面对于 DC之间的位图拷贝采用了两种方式:
一种是 Aero 关闭 或者 窗口尺寸较上次有变化时,采用PrintWindow():
BOOL result = FALSE;
if (!window_capture_helper_.IsAeroEnabled() ||
!previous_size_.equals(frame->size())) {
result = PrintWindow(window_, mem_dc, 0);
}
另一种是 Aero 开启 并且 窗口尺寸保持不变时 或者 PrintWindow()失败时,采用GDI接口BitBlt():
// Aero is enabled or PrintWindow() failed, use BitBlt.
if (!result) {
result = BitBlt(mem_dc, 0, 0, frame->size().width(), frame->size().height(),
window_dc, cropped_rect.left() - original_rect.left(),
cropped_rect.top() - original_rect.top(), SRCCOPY);
}