зеркало из https://github.com/mozilla/gecko-dev.git
357 строки
10 KiB
C++
357 строки
10 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "InProcessWinCompositorWidget.h"
|
|
|
|
#include "mozilla/StaticPrefs_layers.h"
|
|
#include "mozilla/gfx/DeviceManagerDx.h"
|
|
#include "mozilla/gfx/Point.h"
|
|
#include "mozilla/layers/Compositor.h"
|
|
#include "mozilla/layers/CompositorThread.h"
|
|
#include "mozilla/webrender/RenderThread.h"
|
|
#include "mozilla/widget/PlatformWidgetTypes.h"
|
|
#include "gfxPlatform.h"
|
|
#include "HeadlessCompositorWidget.h"
|
|
#include "HeadlessWidget.h"
|
|
#include "nsWindow.h"
|
|
#include "VsyncDispatcher.h"
|
|
#include "WinCompositorWindowThread.h"
|
|
#include "VRShMem.h"
|
|
|
|
#include <ddraw.h>
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
using namespace mozilla::gfx;
|
|
using namespace mozilla;
|
|
|
|
/* static */
|
|
RefPtr<CompositorWidget> CompositorWidget::CreateLocal(
|
|
const CompositorWidgetInitData& aInitData,
|
|
const layers::CompositorOptions& aOptions, nsIWidget* aWidget) {
|
|
if (aInitData.type() ==
|
|
CompositorWidgetInitData::THeadlessCompositorWidgetInitData) {
|
|
return new HeadlessCompositorWidget(
|
|
aInitData.get_HeadlessCompositorWidgetInitData(), aOptions,
|
|
static_cast<HeadlessWidget*>(aWidget));
|
|
} else {
|
|
return new InProcessWinCompositorWidget(
|
|
aInitData.get_WinCompositorWidgetInitData(), aOptions,
|
|
static_cast<nsWindow*>(aWidget));
|
|
}
|
|
}
|
|
|
|
InProcessWinCompositorWidget::InProcessWinCompositorWidget(
|
|
const WinCompositorWidgetInitData& aInitData,
|
|
const layers::CompositorOptions& aOptions, nsWindow* aWindow)
|
|
: WinCompositorWidget(aInitData, aOptions),
|
|
mWindow(aWindow),
|
|
mWnd(reinterpret_cast<HWND>(aInitData.hWnd())),
|
|
mTransparentSurfaceLock("mTransparentSurfaceLock"),
|
|
mTransparencyMode(aInitData.transparencyMode()),
|
|
mMemoryDC(nullptr),
|
|
mCompositeDC(nullptr),
|
|
mLockedBackBufferData(nullptr) {
|
|
MOZ_ASSERT(mWindow);
|
|
MOZ_ASSERT(mWnd && ::IsWindow(mWnd));
|
|
|
|
// mNotDeferEndRemoteDrawing is set on the main thread during init,
|
|
// but is only accessed after on the compositor thread.
|
|
mNotDeferEndRemoteDrawing =
|
|
StaticPrefs::layers_offmainthreadcomposition_frame_rate() == 0 ||
|
|
gfxPlatform::IsInLayoutAsapMode() || gfxPlatform::ForceSoftwareVsync();
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::OnDestroyWindow() {
|
|
EnterPresentLock();
|
|
MutexAutoLock lock(mTransparentSurfaceLock);
|
|
mTransparentSurface = nullptr;
|
|
mMemoryDC = nullptr;
|
|
LeavePresentLock();
|
|
}
|
|
|
|
bool InProcessWinCompositorWidget::OnWindowResize(
|
|
const LayoutDeviceIntSize& aSize) {
|
|
return true;
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::OnWindowModeChange(nsSizeMode aSizeMode) {}
|
|
|
|
bool InProcessWinCompositorWidget::PreRender(WidgetRenderingContext* aContext) {
|
|
// This can block waiting for WM_SETTEXT to finish
|
|
// Using PreRender is unnecessarily pessimistic because
|
|
// we technically only need to block during the present call
|
|
// not all of compositor rendering
|
|
mPresentLock.Enter();
|
|
return true;
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::PostRender(
|
|
WidgetRenderingContext* aContext) {
|
|
mPresentLock.Leave();
|
|
}
|
|
|
|
LayoutDeviceIntSize InProcessWinCompositorWidget::GetClientSize() {
|
|
RECT r;
|
|
if (!::GetClientRect(mWnd, &r)) {
|
|
return LayoutDeviceIntSize();
|
|
}
|
|
return LayoutDeviceIntSize(r.right - r.left, r.bottom - r.top);
|
|
}
|
|
|
|
already_AddRefed<gfx::DrawTarget>
|
|
InProcessWinCompositorWidget::StartRemoteDrawing() {
|
|
MutexAutoLock lock(mTransparentSurfaceLock);
|
|
|
|
MOZ_ASSERT(!mCompositeDC);
|
|
|
|
RefPtr<gfxASurface> surf;
|
|
if (mTransparencyMode == eTransparencyTransparent) {
|
|
surf = EnsureTransparentSurface();
|
|
}
|
|
|
|
// Must call this after EnsureTransparentSurface(), since it could update
|
|
// the DC.
|
|
HDC dc = GetWindowSurface();
|
|
if (!surf) {
|
|
if (!dc) {
|
|
return nullptr;
|
|
}
|
|
uint32_t flags = (mTransparencyMode == eTransparencyOpaque)
|
|
? 0
|
|
: gfxWindowsSurface::FLAG_IS_TRANSPARENT;
|
|
surf = new gfxWindowsSurface(dc, flags);
|
|
}
|
|
|
|
IntSize size = surf->GetSize();
|
|
if (size.width <= 0 || size.height <= 0) {
|
|
if (dc) {
|
|
FreeWindowSurface(dc);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<DrawTarget> dt =
|
|
mozilla::gfx::Factory::CreateDrawTargetForCairoSurface(
|
|
surf->CairoSurface(), size);
|
|
if (dt) {
|
|
mCompositeDC = dc;
|
|
} else {
|
|
FreeWindowSurface(dc);
|
|
}
|
|
|
|
return dt.forget();
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::EndRemoteDrawing() {
|
|
MOZ_ASSERT(!mLockedBackBufferData);
|
|
|
|
if (mTransparencyMode == eTransparencyTransparent) {
|
|
MOZ_ASSERT(mTransparentSurface);
|
|
RedrawTransparentWindow();
|
|
}
|
|
if (mCompositeDC) {
|
|
FreeWindowSurface(mCompositeDC);
|
|
}
|
|
mCompositeDC = nullptr;
|
|
}
|
|
|
|
bool InProcessWinCompositorWidget::NeedsToDeferEndRemoteDrawing() {
|
|
if (mNotDeferEndRemoteDrawing) {
|
|
return false;
|
|
}
|
|
|
|
IDirectDraw7* ddraw = DeviceManagerDx::Get()->GetDirectDraw();
|
|
if (!ddraw) {
|
|
return false;
|
|
}
|
|
|
|
DWORD scanLine = 0;
|
|
int height = ::GetSystemMetrics(SM_CYSCREEN);
|
|
HRESULT ret = ddraw->GetScanLine(&scanLine);
|
|
if (ret == DDERR_VERTICALBLANKINPROGRESS) {
|
|
scanLine = 0;
|
|
} else if (ret != DD_OK) {
|
|
return false;
|
|
}
|
|
|
|
// Check if there is a risk of tearing with GDI.
|
|
if (static_cast<int>(scanLine) > height / 2) {
|
|
// No need to defer.
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
already_AddRefed<gfx::DrawTarget>
|
|
InProcessWinCompositorWidget::GetBackBufferDrawTarget(
|
|
gfx::DrawTarget* aScreenTarget, const gfx::IntRect& aRect,
|
|
bool* aOutIsCleared) {
|
|
MOZ_ASSERT(!mLockedBackBufferData);
|
|
|
|
RefPtr<gfx::DrawTarget> target = CompositorWidget::GetBackBufferDrawTarget(
|
|
aScreenTarget, aRect, aOutIsCleared);
|
|
if (!target) {
|
|
return nullptr;
|
|
}
|
|
|
|
MOZ_ASSERT(target->GetBackendType() == BackendType::CAIRO);
|
|
|
|
uint8_t* destData;
|
|
IntSize destSize;
|
|
int32_t destStride;
|
|
SurfaceFormat destFormat;
|
|
if (!target->LockBits(&destData, &destSize, &destStride, &destFormat)) {
|
|
// LockBits is not supported. Use original DrawTarget.
|
|
return target.forget();
|
|
}
|
|
|
|
RefPtr<gfx::DrawTarget> dataTarget = Factory::CreateDrawTargetForData(
|
|
BackendType::CAIRO, destData, destSize, destStride, destFormat);
|
|
mLockedBackBufferData = destData;
|
|
|
|
return dataTarget.forget();
|
|
}
|
|
|
|
already_AddRefed<gfx::SourceSurface>
|
|
InProcessWinCompositorWidget::EndBackBufferDrawing() {
|
|
if (mLockedBackBufferData) {
|
|
MOZ_ASSERT(mLastBackBuffer);
|
|
mLastBackBuffer->ReleaseBits(mLockedBackBufferData);
|
|
mLockedBackBufferData = nullptr;
|
|
}
|
|
return CompositorWidget::EndBackBufferDrawing();
|
|
}
|
|
|
|
bool InProcessWinCompositorWidget::InitCompositor(
|
|
layers::Compositor* aCompositor) {
|
|
if (aCompositor->GetBackendType() == layers::LayersBackend::LAYERS_BASIC) {
|
|
DeviceManagerDx::Get()->InitializeDirectDraw();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::EnterPresentLock() { mPresentLock.Enter(); }
|
|
|
|
void InProcessWinCompositorWidget::LeavePresentLock() { mPresentLock.Leave(); }
|
|
|
|
RefPtr<gfxASurface> InProcessWinCompositorWidget::EnsureTransparentSurface() {
|
|
mTransparentSurfaceLock.AssertCurrentThreadOwns();
|
|
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
|
|
|
|
IntSize size = GetClientSize().ToUnknownSize();
|
|
if (!mTransparentSurface || mTransparentSurface->GetSize() != size) {
|
|
mTransparentSurface = nullptr;
|
|
mMemoryDC = nullptr;
|
|
CreateTransparentSurface(size);
|
|
}
|
|
|
|
RefPtr<gfxASurface> surface = mTransparentSurface;
|
|
return surface.forget();
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::CreateTransparentSurface(
|
|
const gfx::IntSize& aSize) {
|
|
mTransparentSurfaceLock.AssertCurrentThreadOwns();
|
|
MOZ_ASSERT(!mTransparentSurface && !mMemoryDC);
|
|
RefPtr<gfxWindowsSurface> surface =
|
|
new gfxWindowsSurface(aSize, SurfaceFormat::A8R8G8B8_UINT32);
|
|
mTransparentSurface = surface;
|
|
mMemoryDC = surface->GetDC();
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::UpdateTransparency(
|
|
nsTransparencyMode aMode) {
|
|
EnterPresentLock();
|
|
MutexAutoLock lock(mTransparentSurfaceLock);
|
|
if (mTransparencyMode == aMode) {
|
|
return;
|
|
}
|
|
|
|
mTransparencyMode = aMode;
|
|
mTransparentSurface = nullptr;
|
|
mMemoryDC = nullptr;
|
|
|
|
if (mTransparencyMode == eTransparencyTransparent) {
|
|
EnsureTransparentSurface();
|
|
}
|
|
LeavePresentLock();
|
|
}
|
|
|
|
bool InProcessWinCompositorWidget::HasGlass() const {
|
|
MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread() ||
|
|
wr::RenderThread::IsInRenderThread());
|
|
|
|
nsTransparencyMode transparencyMode = mTransparencyMode;
|
|
return transparencyMode == eTransparencyGlass ||
|
|
transparencyMode == eTransparencyBorderlessGlass;
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::ClearTransparentWindow() {
|
|
EnterPresentLock();
|
|
MutexAutoLock lock(mTransparentSurfaceLock);
|
|
if (!mTransparentSurface) {
|
|
return;
|
|
}
|
|
|
|
EnsureTransparentSurface();
|
|
|
|
IntSize size = mTransparentSurface->GetSize();
|
|
if (!size.IsEmpty()) {
|
|
RefPtr<DrawTarget> drawTarget =
|
|
gfxPlatform::CreateDrawTargetForSurface(mTransparentSurface, size);
|
|
if (!drawTarget) {
|
|
return;
|
|
}
|
|
drawTarget->ClearRect(Rect(0, 0, size.width, size.height));
|
|
RedrawTransparentWindow();
|
|
}
|
|
LeavePresentLock();
|
|
}
|
|
|
|
bool InProcessWinCompositorWidget::RedrawTransparentWindow() {
|
|
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
|
|
|
|
LayoutDeviceIntSize size = GetClientSize();
|
|
|
|
::GdiFlush();
|
|
|
|
BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
|
|
SIZE winSize = {size.width, size.height};
|
|
POINT srcPos = {0, 0};
|
|
HWND hWnd = WinUtils::GetTopLevelHWND(mWnd, true);
|
|
RECT winRect;
|
|
::GetWindowRect(hWnd, &winRect);
|
|
|
|
// perform the alpha blend
|
|
return !!::UpdateLayeredWindow(hWnd, nullptr, (POINT*)&winRect, &winSize,
|
|
mMemoryDC, &srcPos, 0, &bf, ULW_ALPHA);
|
|
}
|
|
|
|
HDC InProcessWinCompositorWidget::GetWindowSurface() {
|
|
return eTransparencyTransparent == mTransparencyMode ? mMemoryDC
|
|
: ::GetDC(mWnd);
|
|
}
|
|
|
|
void InProcessWinCompositorWidget::FreeWindowSurface(HDC dc) {
|
|
if (eTransparencyTransparent != mTransparencyMode) ::ReleaseDC(mWnd, dc);
|
|
}
|
|
|
|
bool InProcessWinCompositorWidget::IsHidden() const { return ::IsIconic(mWnd); }
|
|
|
|
nsIWidget* InProcessWinCompositorWidget::RealWidget() { return mWindow; }
|
|
|
|
void InProcessWinCompositorWidget::ObserveVsync(VsyncObserver* aObserver) {
|
|
if (RefPtr<CompositorVsyncDispatcher> cvd =
|
|
mWindow->GetCompositorVsyncDispatcher()) {
|
|
cvd->SetCompositorVsyncObserver(aObserver);
|
|
}
|
|
}
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|