Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "DrawTargetCairo.h"
#include "SourceSurfaceCairo.h"
#include "PathCairo.h"
#include "HelpersCairo.h"
#include "BorrowedContext.h"
#include "FilterNodeSoftware.h"
#include "mozilla/Scoped.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Vector.h"
#include "mozilla/StaticPrefs_print.h"
#include "cairo.h"
#include "cairo-tee.h"
#include <string.h>
#include "Blur.h"
#include "Logging.h"
#include "Tools.h"
#ifdef CAIRO_HAS_QUARTZ_SURFACE
# include "cairo-quartz.h"
# ifdef MOZ_WIDGET_COCOA
# include <ApplicationServices/ApplicationServices.h>
# endif
#endif
#ifdef CAIRO_HAS_XLIB_SURFACE
# include "cairo-xlib.h"
# include "cairo-xlib-xrender.h"
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
# include "cairo-win32.h"
#endif
#define PIXMAN_DONT_DEFINE_STDINT
#include "pixman.h"
#include <algorithm>
// 2^23
#define CAIRO_COORD_MAX (Float(0x7fffff))
namespace mozilla {
MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedCairoSurface, cairo_surface_t,
cairo_surface_destroy);
namespace gfx {
cairo_surface_t* DrawTargetCairo::mDummySurface;
namespace {
// An RAII class to prepare to draw a context and optional path. Saves and
// restores the context on construction/destruction.
class AutoPrepareForDrawing {
public:
AutoPrepareForDrawing(DrawTargetCairo* dt, cairo_t* ctx) : mCtx(ctx) {
dt->PrepareForDrawing(ctx);
cairo_save(mCtx);
MOZ_ASSERT(cairo_status(mCtx) ||
dt->GetTransform().FuzzyEquals(GetTransform()));
}
AutoPrepareForDrawing(DrawTargetCairo* dt, cairo_t* ctx, const Path* path)
: mCtx(ctx) {
dt->PrepareForDrawing(ctx, path);
cairo_save(mCtx);
MOZ_ASSERT(cairo_status(mCtx) ||
dt->GetTransform().FuzzyEquals(GetTransform()));
}
~AutoPrepareForDrawing() {
cairo_restore(mCtx);
cairo_status_t status = cairo_status(mCtx);
if (status) {
gfxWarning() << "DrawTargetCairo context in error state: "
<< cairo_status_to_string(status) << "(" << status << ")";
}
}
private:
#ifdef DEBUG
Matrix GetTransform() {
cairo_matrix_t mat;
cairo_get_matrix(mCtx, &mat);
return Matrix(mat.xx, mat.yx, mat.xy, mat.yy, mat.x0, mat.y0);
}
#endif
cairo_t* mCtx;
};
/* Clamp r to (0,0) (2^23,2^23)
* these are to be device coordinates.
*
* Returns false if the rectangle is completely out of bounds,
* true otherwise.
*
* This function assumes that it will be called with a rectangle being
* drawn into a surface with an identity transformation matrix; that
* is, anything above or to the left of (0,0) will be offscreen.
*
* First it checks if the rectangle is entirely beyond
* CAIRO_COORD_MAX; if so, it can't ever appear on the screen --
* false is returned.
*
* Then it shifts any rectangles with x/y < 0 so that x and y are = 0,
* and adjusts the width and height appropriately. For example, a
* rectangle from (0,-5) with dimensions (5,10) will become a
* rectangle from (0,0) with dimensions (5,5).
*
* If after negative x/y adjustment to 0, either the width or height
* is negative, then the rectangle is completely offscreen, and
* nothing is drawn -- false is returned.
*
* Finally, if x+width or y+height are greater than CAIRO_COORD_MAX,
* the width and height are clamped such x+width or y+height are equal
* to CAIRO_COORD_MAX, and true is returned.
*/
static bool ConditionRect(Rect& r) {
// if either x or y is way out of bounds;
// note that we don't handle negative w/h here
if (r.X() > CAIRO_COORD_MAX || r.Y() > CAIRO_COORD_MAX) return false;
if (r.X() < 0.f) {
r.SetWidth(r.XMost());
if (r.Width() < 0.f) return false;
r.MoveToX(0.f);
}
if (r.XMost() > CAIRO_COORD_MAX) {
r.SetRightEdge(CAIRO_COORD_MAX);
}
if (r.Y() < 0.f) {
r.SetHeight(r.YMost());
if (r.Height() < 0.f) return false;
r.MoveToY(0.f);
}
if (r.YMost() > CAIRO_COORD_MAX) {
r.SetBottomEdge(CAIRO_COORD_MAX);
}
return true;
}
} // end anonymous namespace
static bool SupportsSelfCopy(cairo_surface_t* surface) {
switch (cairo_surface_get_type(surface)) {
#ifdef CAIRO_HAS_QUARTZ_SURFACE
case CAIRO_SURFACE_TYPE_QUARTZ:
return true;
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
case CAIRO_SURFACE_TYPE_WIN32:
case CAIRO_SURFACE_TYPE_WIN32_PRINTING:
return true;
#endif
default:
return false;
}
}
static bool PatternIsCompatible(const Pattern& aPattern) {
switch (aPattern.GetType()) {
case PatternType::LINEAR_GRADIENT: {
const LinearGradientPattern& pattern =
static_cast<const LinearGradientPattern&>(aPattern);
return pattern.mStops->GetBackendType() == BackendType::CAIRO;
}
case PatternType::RADIAL_GRADIENT: {
const RadialGradientPattern& pattern =
static_cast<const RadialGradientPattern&>(aPattern);
return pattern.mStops->GetBackendType() == BackendType::CAIRO;
}
case PatternType::CONIC_GRADIENT: {
const ConicGradientPattern& pattern =
static_cast<const ConicGradientPattern&>(aPattern);
return pattern.mStops->GetBackendType() == BackendType::CAIRO;
}
default:
return true;
}
}
static cairo_user_data_key_t surfaceDataKey;
static void ReleaseData(void* aData) {
DataSourceSurface* data = static_cast<DataSourceSurface*>(aData);
data->Unmap();
data->Release();
}
static cairo_surface_t* CopyToImageSurface(unsigned char* aData,
const IntRect& aRect,
int32_t aStride,
SurfaceFormat aFormat) {
MOZ_ASSERT(aData);
auto aRectWidth = aRect.Width();
auto aRectHeight = aRect.Height();
cairo_surface_t* surf = cairo_image_surface_create(
GfxFormatToCairoFormat(aFormat), aRectWidth, aRectHeight);
// In certain scenarios, requesting larger than 8k image fails. Bug 803568
// covers the details of how to run into it, but the full detailed
// investigation hasn't been done to determine the underlying cause. We
// will just handle the failure to allocate the surface to avoid a crash.
if (cairo_surface_status(surf)) {
gfxWarning() << "Invalid surface DTC " << cairo_surface_status(surf);
return nullptr;
}
unsigned char* surfData = cairo_image_surface_get_data(surf);
int surfStride = cairo_image_surface_get_stride(surf);
int32_t pixelWidth = BytesPerPixel(aFormat);
unsigned char* source = aData + aRect.Y() * aStride + aRect.X() * pixelWidth;
MOZ_ASSERT(aStride >= aRectWidth * pixelWidth);
for (int32_t y = 0; y < aRectHeight; ++y) {
memcpy(surfData + y * surfStride, source + y * aStride,
aRectWidth * pixelWidth);
}
cairo_surface_mark_dirty(surf);
return surf;
}
/**
* If aSurface can be represented as a surface of type
* CAIRO_SURFACE_TYPE_IMAGE then returns that surface. Does
* not add a reference.
*/
static cairo_surface_t* GetAsImageSurface(cairo_surface_t* aSurface) {
if (cairo_surface_get_type(aSurface) == CAIRO_SURFACE_TYPE_IMAGE) {
return aSurface;
#ifdef CAIRO_HAS_WIN32_SURFACE
} else if (cairo_surface_get_type(aSurface) == CAIRO_SURFACE_TYPE_WIN32) {
return cairo_win32_surface_get_image(aSurface);
#endif
}
return nullptr;
}
static cairo_surface_t* CreateSubImageForData(unsigned char* aData,
const IntRect& aRect, int aStride,
SurfaceFormat aFormat) {
if (!aData) {
gfxWarning() << "DrawTargetCairo.CreateSubImageForData null aData";
return nullptr;
}
unsigned char* data =
aData + aRect.Y() * aStride + aRect.X() * BytesPerPixel(aFormat);
cairo_surface_t* image = cairo_image_surface_create_for_data(
data, GfxFormatToCairoFormat(aFormat), aRect.Width(), aRect.Height(),
aStride);
cairo_surface_set_device_offset(image, -aRect.X(), -aRect.Y());
return image;
}
/**
* Returns a referenced cairo_surface_t representing the
* sub-image specified by aSubImage.
*/
static cairo_surface_t* ExtractSubImage(cairo_surface_t* aSurface,
const IntRect& aSubImage,
SurfaceFormat aFormat) {
// No need to worry about retaining a reference to the original
// surface since the only caller of this function guarantees
// that aSurface will stay alive as long as the result
cairo_surface_t* image = GetAsImageSurface(aSurface);
if (image) {
image =
CreateSubImageForData(cairo_image_surface_get_data(image), aSubImage,
cairo_image_surface_get_stride(image), aFormat);
return image;
}
cairo_surface_t* similar = cairo_surface_create_similar(
aSurface, cairo_surface_get_content(aSurface), aSubImage.Width(),
aSubImage.Height());
cairo_t* ctx = cairo_create(similar);
cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(ctx, aSurface, -aSubImage.X(), -aSubImage.Y());
cairo_paint(ctx);
cairo_destroy(ctx);
cairo_surface_set_device_offset(similar, -aSubImage.X(), -aSubImage.Y());
return similar;
}
/**
* Returns cairo surface for the given SourceSurface.
* If possible, it will use the cairo_surface associated with aSurface,
* otherwise, it will create a new cairo_surface.
* In either case, the caller must call cairo_surface_destroy on the
* result when it is done with it.
*/
static cairo_surface_t* GetCairoSurfaceForSourceSurface(
SourceSurface* aSurface, bool aExistingOnly = false,
const IntRect& aSubImage = IntRect()) {
if (!aSurface) {
return nullptr;
}
IntRect subimage = IntRect(IntPoint(), aSurface->GetSize());
if (!aSubImage.IsEmpty()) {
MOZ_ASSERT(!aExistingOnly);
MOZ_ASSERT(subimage.Contains(aSubImage));
subimage = aSubImage;
}
if (aSurface->GetType() == SurfaceType::CAIRO) {
cairo_surface_t* surf =
static_cast<SourceSurfaceCairo*>(aSurface)->GetSurface();
if (aSubImage.IsEmpty()) {
cairo_surface_reference(surf);
} else {
surf = ExtractSubImage(surf, subimage, aSurface->GetFormat());
}
return surf;
}
if (aSurface->GetType() == SurfaceType::CAIRO_IMAGE) {
cairo_surface_t* surf =
static_cast<const DataSourceSurfaceCairo*>(aSurface)->GetSurface();
if (aSubImage.IsEmpty()) {
cairo_surface_reference(surf);
} else {
surf = ExtractSubImage(surf, subimage, aSurface->GetFormat());
}
return surf;
}
if (aExistingOnly) {
return nullptr;
}
RefPtr<DataSourceSurface> data = aSurface->GetDataSurface();
if (!data) {
return nullptr;
}
DataSourceSurface::MappedSurface map;
if (!data->Map(DataSourceSurface::READ, &map)) {
return nullptr;
}
cairo_surface_t* surf = CreateSubImageForData(map.mData, subimage,
map.mStride, data->GetFormat());
// In certain scenarios, requesting larger than 8k image fails. Bug 803568
// covers the details of how to run into it, but the full detailed
// investigation hasn't been done to determine the underlying cause. We
// will just handle the failure to allocate the surface to avoid a crash.
if (!surf || cairo_surface_status(surf)) {
if (surf && (cairo_surface_status(surf) == CAIRO_STATUS_INVALID_STRIDE)) {
// If we failed because of an invalid stride then copy into
// a new surface with a stride that cairo chooses. No need to
// set user data since we're not dependent on the original
// data.
cairo_surface_t* result = CopyToImageSurface(
map.mData, subimage, map.mStride, data->GetFormat());
data->Unmap();
return result;
}
data->Unmap();
return nullptr;
}
cairo_surface_set_user_data(surf, &surfaceDataKey, data.forget().take(),
ReleaseData);
return surf;
}
// An RAII class to temporarily clear any device offset set
// on a surface. Note that this does not take a reference to the
// surface.
class AutoClearDeviceOffset final {
public:
explicit AutoClearDeviceOffset(SourceSurface* aSurface)
: mSurface(nullptr), mX(0), mY(0) {
Init(aSurface);
}
explicit AutoClearDeviceOffset(const Pattern& aPattern)
: mSurface(nullptr), mX(0.0), mY(0.0) {
if (aPattern.GetType() == PatternType::SURFACE) {
const SurfacePattern& pattern =
static_cast<const SurfacePattern&>(aPattern);
Init(pattern.mSurface);
}
}
~AutoClearDeviceOffset() {
if (mSurface) {
cairo_surface_set_device_offset(mSurface, mX, mY);
}
}
private:
void Init(SourceSurface* aSurface) {
cairo_surface_t* surface = GetCairoSurfaceForSourceSurface(aSurface, true);
if (surface) {
Init(surface);
cairo_surface_destroy(surface);
}
}
void Init(cairo_surface_t* aSurface) {
mSurface = aSurface;
cairo_surface_get_device_offset(mSurface, &mX, &mY);
cairo_surface_set_device_offset(mSurface, 0, 0);
}
cairo_surface_t* mSurface;
double mX;
double mY;
};
static inline void CairoPatternAddGradientStop(cairo_pattern_t* aPattern,
const GradientStop& aStop,
Float aNudge = 0) {
cairo_pattern_add_color_stop_rgba(aPattern, aStop.offset + aNudge,
aStop.color.r, aStop.color.g, aStop.color.b,
aStop.color.a);
}
// Never returns nullptr. As such, you must always pass in Cairo-compatible
// patterns, most notably gradients with a GradientStopCairo.
// The pattern returned must have cairo_pattern_destroy() called on it by the
// caller.
// As the cairo_pattern_t returned may depend on the Pattern passed in, the
// lifetime of the cairo_pattern_t returned must not exceed the lifetime of the
// Pattern passed in.
static cairo_pattern_t* GfxPatternToCairoPattern(const Pattern& aPattern,
Float aAlpha,
const Matrix& aTransform) {
cairo_pattern_t* pat;
const Matrix* matrix = nullptr;
switch (aPattern.GetType()) {
case PatternType::COLOR: {
DeviceColor color = static_cast<const ColorPattern&>(aPattern).mColor;
pat = cairo_pattern_create_rgba(color.r, color.g, color.b,
color.a * aAlpha);
break;
}
case PatternType::SURFACE: {
const SurfacePattern& pattern =
static_cast<const SurfacePattern&>(aPattern);
cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(
pattern.mSurface, false, pattern.mSamplingRect);
if (!surf) return nullptr;
pat = cairo_pattern_create_for_surface(surf);
matrix = &pattern.mMatrix;
cairo_pattern_set_filter(
pat, GfxSamplingFilterToCairoFilter(pattern.mSamplingFilter));
cairo_pattern_set_extend(pat,
GfxExtendToCairoExtend(pattern.mExtendMode));
cairo_surface_destroy(surf);
break;
}
case PatternType::LINEAR_GRADIENT: {
const LinearGradientPattern& pattern =
static_cast<const LinearGradientPattern&>(aPattern);
pat = cairo_pattern_create_linear(pattern.mBegin.x, pattern.mBegin.y,
pattern.mEnd.x, pattern.mEnd.y);
MOZ_ASSERT(pattern.mStops->GetBackendType() == BackendType::CAIRO);
GradientStopsCairo* cairoStops =
static_cast<GradientStopsCairo*>(pattern.mStops.get());
cairo_pattern_set_extend(
pat, GfxExtendToCairoExtend(cairoStops->GetExtendMode()));
matrix = &pattern.mMatrix;
const std::vector<GradientStop>& stops = cairoStops->GetStops();
for (size_t i = 0; i < stops.size(); ++i) {
CairoPatternAddGradientStop(pat, stops[i]);
}
break;
}
case PatternType::RADIAL_GRADIENT: {
const RadialGradientPattern& pattern =
static_cast<const RadialGradientPattern&>(aPattern);
pat = cairo_pattern_create_radial(pattern.mCenter1.x, pattern.mCenter1.y,
pattern.mRadius1, pattern.mCenter2.x,
pattern.mCenter2.y, pattern.mRadius2);
MOZ_ASSERT(pattern.mStops->GetBackendType() == BackendType::CAIRO);
GradientStopsCairo* cairoStops =
static_cast<GradientStopsCairo*>(pattern.mStops.get());
cairo_pattern_set_extend(
pat, GfxExtendToCairoExtend(cairoStops->GetExtendMode()));
matrix = &pattern.mMatrix;
const std::vector<GradientStop>& stops = cairoStops->GetStops();
for (size_t i = 0; i < stops.size(); ++i) {
CairoPatternAddGradientStop(pat, stops[i]);
}
break;
}
case PatternType::CONIC_GRADIENT: {
// XXX(ntim): Bug 1617039 - Implement conic-gradient for Cairo
pat = cairo_pattern_create_rgba(0.0, 0.0, 0.0, 0.0);
break;
}
default: {
// We should support all pattern types!
MOZ_ASSERT(false);
}
}
// The pattern matrix is a matrix that transforms the pattern into user
// space. Cairo takes a matrix that converts from user space to pattern
// space. Cairo therefore needs the inverse.
if (matrix) {
cairo_matrix_t mat;
GfxMatrixToCairoMatrix(*matrix, mat);
cairo_matrix_invert(&mat);
cairo_pattern_set_matrix(pat, &mat);
}
return pat;
}
static bool NeedIntermediateSurface(const Pattern& aPattern,
const DrawOptions& aOptions) {
// We pre-multiply colours' alpha by the global alpha, so we don't need to
// use an intermediate surface for them.
if (aPattern.GetType() == PatternType::COLOR) return false;
if (aOptions.mAlpha == 1.0) return false;
return true;
}
DrawTargetCairo::DrawTargetCairo()
: mContext(nullptr),
mSurface(nullptr),
mTransformSingular(false),
mLockedBits(nullptr),
mFontOptions(nullptr) {}
DrawTargetCairo::~DrawTargetCairo() {
cairo_destroy(mContext);
if (mSurface) {
cairo_surface_destroy(mSurface);
mSurface = nullptr;
}
if (mFontOptions) {
cairo_font_options_destroy(mFontOptions);
mFontOptions = nullptr;
}
MOZ_ASSERT(!mLockedBits);
}
bool DrawTargetCairo::IsValid() const {
return mSurface && !cairo_surface_status(mSurface) && mContext &&
!cairo_surface_status(cairo_get_group_target(mContext));
}
DrawTargetType DrawTargetCairo::GetType() const {
if (mContext) {
cairo_surface_type_t type = cairo_surface_get_type(mSurface);
if (type == CAIRO_SURFACE_TYPE_TEE) {
type = cairo_surface_get_type(cairo_tee_surface_index(mSurface, 0));
MOZ_ASSERT(type != CAIRO_SURFACE_TYPE_TEE, "C'mon!");
MOZ_ASSERT(
type == cairo_surface_get_type(cairo_tee_surface_index(mSurface, 1)),
"What should we do here?");
}
switch (type) {
case CAIRO_SURFACE_TYPE_PDF:
case CAIRO_SURFACE_TYPE_PS:
case CAIRO_SURFACE_TYPE_SVG:
case CAIRO_SURFACE_TYPE_WIN32_PRINTING:
case CAIRO_SURFACE_TYPE_XML:
return DrawTargetType::VECTOR;
case CAIRO_SURFACE_TYPE_VG:
case CAIRO_SURFACE_TYPE_GL:
case CAIRO_SURFACE_TYPE_GLITZ:
case CAIRO_SURFACE_TYPE_QUARTZ:
case CAIRO_SURFACE_TYPE_DIRECTFB:
return DrawTargetType::HARDWARE_RASTER;
case CAIRO_SURFACE_TYPE_SKIA:
case CAIRO_SURFACE_TYPE_QT:
MOZ_FALLTHROUGH_ASSERT(
"Can't determine actual DrawTargetType for DrawTargetCairo - "
"assuming SOFTWARE_RASTER");
case CAIRO_SURFACE_TYPE_IMAGE:
case CAIRO_SURFACE_TYPE_XLIB:
case CAIRO_SURFACE_TYPE_XCB:
case CAIRO_SURFACE_TYPE_WIN32:
case CAIRO_SURFACE_TYPE_BEOS:
case CAIRO_SURFACE_TYPE_OS2:
case CAIRO_SURFACE_TYPE_QUARTZ_IMAGE:
case CAIRO_SURFACE_TYPE_SCRIPT:
case CAIRO_SURFACE_TYPE_RECORDING:
case CAIRO_SURFACE_TYPE_DRM:
case CAIRO_SURFACE_TYPE_SUBSURFACE:
case CAIRO_SURFACE_TYPE_TEE: // included to silence warning about
// unhandled enum value
return DrawTargetType::SOFTWARE_RASTER;
default:
MOZ_CRASH("GFX: Unsupported cairo surface type");
}
}
MOZ_ASSERT(false, "Could not determine DrawTargetType for DrawTargetCairo");
return DrawTargetType::SOFTWARE_RASTER;
}
IntSize DrawTargetCairo::GetSize() const { return mSize; }
SurfaceFormat GfxFormatForCairoSurface(cairo_surface_t* surface) {
cairo_surface_type_t type = cairo_surface_get_type(surface);
if (type == CAIRO_SURFACE_TYPE_IMAGE) {
return CairoFormatToGfxFormat(cairo_image_surface_get_format(surface));
}
#ifdef CAIRO_HAS_XLIB_SURFACE
// xlib is currently the only Cairo backend that creates 16bpp surfaces
if (type == CAIRO_SURFACE_TYPE_XLIB &&
cairo_xlib_surface_get_depth(surface) == 16) {
return SurfaceFormat::R5G6B5_UINT16;
}
#endif
return CairoContentToGfxFormat(cairo_surface_get_content(surface));
}
already_AddRefed<SourceSurface> DrawTargetCairo::Snapshot() {
if (!IsValid()) {
gfxCriticalNote << "DrawTargetCairo::Snapshot with bad surface "
<< hexa(mSurface) << ", context " << hexa(mContext)
<< ", status "
<< (mSurface ? cairo_surface_status(mSurface) : -1);
return nullptr;
}
if (mSnapshot) {
RefPtr<SourceSurface> snapshot(mSnapshot);
return snapshot.forget();
}
IntSize size = GetSize();
mSnapshot = new SourceSurfaceCairo(mSurface, size,
GfxFormatForCairoSurface(mSurface), this);
RefPtr<SourceSurface> snapshot(mSnapshot);
return snapshot.forget();
}
bool DrawTargetCairo::LockBits(uint8_t** aData, IntSize* aSize,
int32_t* aStride, SurfaceFormat* aFormat,
IntPoint* aOrigin) {
cairo_surface_t* target = cairo_get_group_target(mContext);
cairo_surface_t* surf = target;
#ifdef CAIRO_HAS_WIN32_SURFACE
if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_WIN32) {
cairo_surface_t* imgsurf = cairo_win32_surface_get_image(surf);
if (imgsurf) {
surf = imgsurf;
}
}
#endif
if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_IMAGE &&
cairo_surface_status(surf) == CAIRO_STATUS_SUCCESS) {
PointDouble offset;
cairo_surface_get_device_offset(target, &offset.x, &offset.y);
// verify the device offset can be converted to integers suitable for a
// bounds rect
IntPoint origin(int32_t(-offset.x), int32_t(-offset.y));
if (-PointDouble(origin) != offset || (!aOrigin && origin != IntPoint())) {
return false;
}
WillChange();
Flush();
mLockedBits = cairo_image_surface_get_data(surf);
*aData = mLockedBits;
*aSize = IntSize(cairo_image_surface_get_width(surf),
cairo_image_surface_get_height(surf));
*aStride = cairo_image_surface_get_stride(surf);
*aFormat = CairoFormatToGfxFormat(cairo_image_surface_get_format(surf));
if (aOrigin) {
*aOrigin = origin;
}
return true;
}
return false;
}
void DrawTargetCairo::ReleaseBits(uint8_t* aData) {
MOZ_ASSERT(mLockedBits == aData);
mLockedBits = nullptr;
cairo_surface_t* surf = cairo_get_group_target(mContext);
#ifdef CAIRO_HAS_WIN32_SURFACE
if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_WIN32) {
cairo_surface_t* imgsurf = cairo_win32_surface_get_image(surf);
if (imgsurf) {
cairo_surface_mark_dirty(imgsurf);
}
}
#endif
cairo_surface_mark_dirty(surf);
}
void DrawTargetCairo::Flush() {
cairo_surface_t* surf = cairo_get_group_target(mContext);
cairo_surface_flush(surf);
}
void DrawTargetCairo::PrepareForDrawing(cairo_t* aContext,
const Path* aPath /* = nullptr */) {
WillChange(aPath);
}
cairo_surface_t* DrawTargetCairo::GetDummySurface() {
if (mDummySurface) {
return mDummySurface;
}
mDummySurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
return mDummySurface;
}
static void PaintWithAlpha(cairo_t* aContext, const DrawOptions& aOptions) {
if (aOptions.mCompositionOp == CompositionOp::OP_SOURCE) {
// Cairo treats the source operator like a lerp when alpha is < 1.
// Approximate the desired operator by: out = 0; out += src*alpha;
if (aOptions.mAlpha == 1) {
cairo_set_operator(aContext, CAIRO_OPERATOR_SOURCE);
cairo_paint(aContext);
} else {
cairo_set_operator(aContext, CAIRO_OPERATOR_CLEAR);
cairo_paint(aContext);
cairo_set_operator(aContext, CAIRO_OPERATOR_ADD);
cairo_paint_with_alpha(aContext, aOptions.mAlpha);
}
} else {
cairo_set_operator(aContext, GfxOpToCairoOp(aOptions.mCompositionOp));
cairo_paint_with_alpha(aContext, aOptions.mAlpha);
}
}
void DrawTargetCairo::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
const Rect& aSource,
const DrawSurfaceOptions& aSurfOptions,
const DrawOptions& aOptions) {
if (mTransformSingular || aDest.IsEmpty()) {
return;
}
if (!IsValid() || !aSurface) {
gfxCriticalNote << "DrawSurface with bad surface "
<< cairo_surface_status(cairo_get_group_target(mContext));
return;
}
AutoPrepareForDrawing prep(this, mContext);
AutoClearDeviceOffset clear(aSurface);
float sx = aSource.Width() / aDest.Width();
float sy = aSource.Height() / aDest.Height();
cairo_matrix_t src_mat;
cairo_matrix_init_translate(&src_mat, aSource.X(), aSource.Y());
cairo_matrix_scale(&src_mat, sx, sy);
cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aSurface);
if (!surf) {
gfxWarning()
<< "Failed to create cairo surface for DrawTargetCairo::DrawSurface";
return;
}
cairo_pattern_t* pat = cairo_pattern_create_for_surface(surf);
cairo_surface_destroy(surf);
cairo_pattern_set_matrix(pat, &src_mat);
cairo_pattern_set_filter(
pat, GfxSamplingFilterToCairoFilter(aSurfOptions.mSamplingFilter));
cairo_pattern_set_extend(pat, CAIRO_EXTEND_PAD);
cairo_set_antialias(mContext,
GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));
// If the destination rect covers the entire clipped area, then unbounded and
// bounded operations are identical, and we don't need to push a group.
bool needsGroup = !IsOperatorBoundByMask(aOptions.mCompositionOp) &&
!aDest.Contains(GetUserSpaceClip());
cairo_translate(mContext, aDest.X(), aDest.Y());
if (needsGroup) {
cairo_push_group(mContext);
cairo_new_path(mContext);
cairo_rectangle(mContext, 0, 0, aDest.Width(), aDest.Height());
cairo_set_source(mContext, pat);
cairo_fill(mContext);
cairo_pop_group_to_source(mContext);
} else {
cairo_new_path(mContext);
cairo_rectangle(mContext, 0, 0, aDest.Width(), aDest.Height());
cairo_clip(mContext);
cairo_set_source(mContext, pat);
}
PaintWithAlpha(mContext, aOptions);
cairo_pattern_destroy(pat);
}
void DrawTargetCairo::DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
const Point& aDestPoint,
const DrawOptions& aOptions) {
FilterNodeSoftware* filter = static_cast<FilterNodeSoftware*>(aNode);
filter->Draw(this, aSourceRect, aDestPoint, aOptions);
}
void DrawTargetCairo::DrawSurfaceWithShadow(SourceSurface* aSurface,
const Point& aDest,
const DeviceColor& aColor,
const Point& aOffset, Float aSigma,
CompositionOp aOperator) {
if (!IsValid() || !aSurface) {
gfxCriticalNote << "DrawSurfaceWithShadow with bad surface "
<< cairo_surface_status(cairo_get_group_target(mContext));
return;
}
if (aSurface->GetType() != SurfaceType::CAIRO) {
return;
}
AutoClearDeviceOffset clear(aSurface);
Float width = Float(aSurface->GetSize().width);
Float height = Float(aSurface->GetSize().height);
SourceSurfaceCairo* source = static_cast<SourceSurfaceCairo*>(aSurface);
cairo_surface_t* sourcesurf = source->GetSurface();
cairo_surface_t* blursurf;
cairo_surface_t* surf;
// We only use the A8 surface for blurred shadows. Unblurred shadows can just
// use the RGBA surface directly.
if (cairo_surface_get_type(sourcesurf) == CAIRO_SURFACE_TYPE_TEE) {
blursurf = cairo_tee_surface_index(sourcesurf, 0);
surf = cairo_tee_surface_index(sourcesurf, 1);
} else {
blursurf = sourcesurf;
surf = sourcesurf;
}
if (aSigma != 0.0f) {
MOZ_ASSERT(cairo_surface_get_type(blursurf) == CAIRO_SURFACE_TYPE_IMAGE);
Rect extents(0, 0, width, height);
AlphaBoxBlur blur(extents, cairo_image_surface_get_stride(blursurf), aSigma,
aSigma);
blur.Blur(cairo_image_surface_get_data(blursurf));
}
WillChange();
ClearSurfaceForUnboundedSource(aOperator);
cairo_save(mContext);
cairo_set_operator(mContext, GfxOpToCairoOp(aOperator));
cairo_identity_matrix(mContext);
cairo_translate(mContext, aDest.x, aDest.y);
bool needsGroup = !IsOperatorBoundByMask(aOperator);
if (needsGroup) {
cairo_push_group(mContext);
}
cairo_set_source_rgba(mContext, aColor.r, aColor.g, aColor.b, aColor.a);
cairo_mask_surface(mContext, blursurf, aOffset.x, aOffset.y);
if (blursurf != surf || aSurface->GetFormat() != SurfaceFormat::A8) {
// Now that the shadow has been drawn, we can draw the surface on top.
cairo_set_source_surface(mContext, surf, 0, 0);
cairo_new_path(mContext);
cairo_rectangle(mContext, 0, 0, width, height);
cairo_fill(mContext);
}
if (needsGroup) {
cairo_pop_group_to_source(mContext);
cairo_paint(mContext);
}
cairo_restore(mContext);
}
void DrawTargetCairo::DrawPattern(const Pattern& aPattern,
const StrokeOptions& aStrokeOptions,
const DrawOptions& aOptions,
DrawPatternType aDrawType,
bool aPathBoundsClip) {
if (!PatternIsCompatible(aPattern)) {
return;
}
AutoClearDeviceOffset clear(aPattern);
cairo_pattern_t* pat =
GfxPatternToCairoPattern(aPattern, aOptions.mAlpha, GetTransform());
if (!pat) {
return;
}
if (cairo_pattern_status(pat)) {
cairo_pattern_destroy(pat);
gfxWarning() << "Invalid pattern";
return;
}
cairo_set_source(mContext, pat);
cairo_set_antialias(mContext,
GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));
if (NeedIntermediateSurface(aPattern, aOptions) ||
(!IsOperatorBoundByMask(aOptions.mCompositionOp) && !aPathBoundsClip)) {
cairo_push_group_with_content(mContext, CAIRO_CONTENT_COLOR_ALPHA);
// Don't want operators to be applied twice
cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);
if (aDrawType == DRAW_STROKE) {
SetCairoStrokeOptions(mContext, aStrokeOptions);
cairo_stroke_preserve(mContext);
} else {
cairo_fill_preserve(mContext);
}
cairo_pop_group_to_source(mContext);
// Now draw the content using the desired operator
PaintWithAlpha(mContext, aOptions);
} else {
cairo_set_operator(mContext, GfxOpToCairoOp(aOptions.mCompositionOp));
if (aDrawType == DRAW_STROKE) {
SetCairoStrokeOptions(mContext, aStrokeOptions);
cairo_stroke_preserve(mContext);
} else {
cairo_fill_preserve(mContext);
}
}
cairo_pattern_destroy(pat);
}
void DrawTargetCairo::FillRect(const Rect& aRect, const Pattern& aPattern,
const DrawOptions& aOptions) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
bool restoreTransform = false;
Matrix mat;
Rect r = aRect;
/* Clamp coordinates to work around a design bug in cairo */
if (r.Width() > CAIRO_COORD_MAX || r.Height() > CAIRO_COORD_MAX ||
r.X() < -CAIRO_COORD_MAX || r.X() > CAIRO_COORD_MAX ||
r.Y() < -CAIRO_COORD_MAX || r.Y() > CAIRO_COORD_MAX) {
if (!mat.IsRectilinear()) {
gfxWarning() << "DrawTargetCairo::FillRect() misdrawing huge Rect "
"with non-rectilinear transform";
}
mat = GetTransform();
r = mat.TransformBounds(r);
if (!ConditionRect(r)) {
gfxWarning() << "Ignoring DrawTargetCairo::FillRect() call with "
"out-of-bounds Rect";
return;
}
restoreTransform = true;
SetTransform(Matrix());
}
cairo_new_path(mContext);
cairo_rectangle(mContext, r.X(), r.Y(), r.Width(), r.Height());
bool pathBoundsClip = false;
if (r.Contains(GetUserSpaceClip())) {
pathBoundsClip = true;
}
DrawPattern(aPattern, StrokeOptions(), aOptions, DRAW_FILL, pathBoundsClip);
if (restoreTransform) {
SetTransform(mat);
}
}
void DrawTargetCairo::CopySurfaceInternal(cairo_surface_t* aSurface,
const IntRect& aSource,
const IntPoint& aDest) {
if (cairo_surface_status(aSurface)) {
gfxWarning() << "Invalid surface" << cairo_surface_status(aSurface);
return;
}
cairo_identity_matrix(mContext);
cairo_set_source_surface(mContext, aSurface, aDest.x - aSource.X(),
aDest.y - aSource.Y());
cairo_set_operator(mContext, CAIRO_OPERATOR_SOURCE);
cairo_set_antialias(mContext, CAIRO_ANTIALIAS_NONE);
cairo_reset_clip(mContext);
cairo_new_path(mContext);
cairo_rectangle(mContext, aDest.x, aDest.y, aSource.Width(),
aSource.Height());
cairo_fill(mContext);
}
void DrawTargetCairo::CopySurface(SourceSurface* aSurface,
const IntRect& aSource,
const IntPoint& aDest) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
AutoClearDeviceOffset clear(aSurface);
if (!aSurface) {
gfxWarning() << "Unsupported surface type specified";
return;
}
cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aSurface);
if (!surf) {
gfxWarning() << "Unsupported surface type specified";
return;
}
CopySurfaceInternal(surf, aSource, aDest);
cairo_surface_destroy(surf);
}
void DrawTargetCairo::CopyRect(const IntRect& aSource, const IntPoint& aDest) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
IntRect source = aSource;
cairo_surface_t* surf = mSurface;
if (!SupportsSelfCopy(mSurface) && aSource.ContainsY(aDest.y)) {
cairo_surface_t* similar = cairo_surface_create_similar(
mSurface, GfxFormatToCairoContent(GetFormat()), aSource.Width(),
aSource.Height());
cairo_t* ctx = cairo_create(similar);
cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(ctx, surf, -aSource.X(), -aSource.Y());
cairo_paint(ctx);
cairo_destroy(ctx);
source.MoveTo(0, 0);
surf = similar;
}
CopySurfaceInternal(surf, source, aDest);
if (surf != mSurface) {
cairo_surface_destroy(surf);
}
}
void DrawTargetCairo::ClearRect(const Rect& aRect) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
if (!mContext || aRect.Width() < 0 || aRect.Height() < 0 ||
!IsFinite(aRect.X()) || !IsFinite(aRect.Width()) ||
!IsFinite(aRect.Y()) || !IsFinite(aRect.Height())) {
gfxCriticalNote << "ClearRect with invalid argument " << gfx::hexa(mContext)
<< " with " << aRect.Width() << "x" << aRect.Height()
<< " [" << aRect.X() << ", " << aRect.Y() << "]";
}
cairo_set_antialias(mContext, CAIRO_ANTIALIAS_NONE);
cairo_new_path(mContext);
cairo_set_operator(mContext, CAIRO_OPERATOR_CLEAR);
cairo_rectangle(mContext, aRect.X(), aRect.Y(), aRect.Width(),
aRect.Height());
cairo_fill(mContext);
}
void DrawTargetCairo::StrokeRect(
const Rect& aRect, const Pattern& aPattern,
const StrokeOptions& aStrokeOptions /* = StrokeOptions() */,
const DrawOptions& aOptions /* = DrawOptions() */) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
cairo_new_path(mContext);
cairo_rectangle(mContext, aRect.X(), aRect.Y(), aRect.Width(),
aRect.Height());
DrawPattern(aPattern, aStrokeOptions, aOptions, DRAW_STROKE);
}
void DrawTargetCairo::StrokeLine(
const Point& aStart, const Point& aEnd, const Pattern& aPattern,
const StrokeOptions& aStrokeOptions /* = StrokeOptions() */,
const DrawOptions& aOptions /* = DrawOptions() */) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
cairo_new_path(mContext);
cairo_move_to(mContext, aStart.x, aStart.y);
cairo_line_to(mContext, aEnd.x, aEnd.y);
DrawPattern(aPattern, aStrokeOptions, aOptions, DRAW_STROKE);
}
void DrawTargetCairo::Stroke(
const Path* aPath, const Pattern& aPattern,
const StrokeOptions& aStrokeOptions /* = StrokeOptions() */,
const DrawOptions& aOptions /* = DrawOptions() */) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext, aPath);
if (aPath->GetBackendType() != BackendType::CAIRO) return;
PathCairo* path =
const_cast<PathCairo*>(static_cast<const PathCairo*>(aPath));
path->SetPathOnContext(mContext);
DrawPattern(aPattern, aStrokeOptions, aOptions, DRAW_STROKE);
}
void DrawTargetCairo::Fill(const Path* aPath, const Pattern& aPattern,
const DrawOptions& aOptions /* = DrawOptions() */) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext, aPath);
if (aPath->GetBackendType() != BackendType::CAIRO) return;
PathCairo* path =
const_cast<PathCairo*>(static_cast<const PathCairo*>(aPath));
path->SetPathOnContext(mContext);
DrawPattern(aPattern, StrokeOptions(), aOptions, DRAW_FILL);
}
bool DrawTargetCairo::IsCurrentGroupOpaque() {
cairo_surface_t* surf = cairo_get_group_target(mContext);
if (!surf) {
return false;
}
return cairo_surface_get_content(surf) == CAIRO_CONTENT_COLOR;
}
void DrawTargetCairo::SetFontOptions(cairo_antialias_t aAAMode) {
// This will attempt to detect if the currently set scaled font on the
// context has enabled subpixel AA. If it is not permitted, then it will
// downgrade to grayscale AA.
// This only currently works effectively for the cairo-ft backend relative
// to system defaults, as only cairo-ft reflect system defaults in the scaled
// font state. However, this will work for cairo-ft on both tree Cairo and
// system Cairo.
// Other backends leave the CAIRO_ANTIALIAS_DEFAULT setting untouched while
// potentially interpreting it as subpixel or even other types of AA that
// can't be safely equivocated with grayscale AA. For this reason we don't
// try to also detect and modify the default AA setting, only explicit
// subpixel AA. These other backends must instead rely on tree Cairo's
// cairo_surface_set_subpixel_antialiasing extension.
// If allowing subpixel AA, then leave Cairo's default AA state.
if (mPermitSubpixelAA && aAAMode == CAIRO_ANTIALIAS_DEFAULT) {
return;
}
if (!mFontOptions) {
mFontOptions = cairo_font_options_create();
if (!mFontOptions) {
gfxWarning() << "Failed allocating Cairo font options";
return;
}
}
cairo_get_font_options(mContext, mFontOptions);
cairo_antialias_t oldAA = cairo_font_options_get_antialias(mFontOptions);
cairo_antialias_t newAA =
aAAMode == CAIRO_ANTIALIAS_DEFAULT ? oldAA : aAAMode;
// Nothing to change if switching to default AA.
if (newAA == CAIRO_ANTIALIAS_DEFAULT) {
return;
}
// If the current font requests subpixel AA, force it to gray since we don't
// allow subpixel AA.
if (!mPermitSubpixelAA && newAA == CAIRO_ANTIALIAS_SUBPIXEL) {
newAA = CAIRO_ANTIALIAS_GRAY;
}
// Only override old AA with lower levels of AA.
if (oldAA == CAIRO_ANTIALIAS_DEFAULT || (int)newAA < (int)oldAA) {
cairo_font_options_set_antialias(mFontOptions, newAA);
cairo_set_font_options(mContext, mFontOptions);
}
}
void DrawTargetCairo::SetPermitSubpixelAA(bool aPermitSubpixelAA) {
DrawTarget::SetPermitSubpixelAA(aPermitSubpixelAA);
#ifdef MOZ_TREE_CAIRO
cairo_surface_set_subpixel_antialiasing(
cairo_get_group_target(mContext),
aPermitSubpixelAA ? CAIRO_SUBPIXEL_ANTIALIASING_ENABLED
: CAIRO_SUBPIXEL_ANTIALIASING_DISABLED);
#endif
}
static bool SupportsVariationSettings(cairo_surface_t* surface) {
switch (cairo_surface_get_type(surface)) {
case CAIRO_SURFACE_TYPE_PDF:
case CAIRO_SURFACE_TYPE_PS:
return false;
default:
return true;
}
}
void DrawTargetCairo::FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,
const Pattern& aPattern,
const DrawOptions& aOptions) {
if (mTransformSingular) {
return;
}
if (!IsValid()) {
gfxDebug() << "FillGlyphs bad surface "
<< cairo_surface_status(cairo_get_group_target(mContext));
return;
}
cairo_scaled_font_t* cairoScaledFont =
aFont ? aFont->GetCairoScaledFont() : nullptr;
if (!cairoScaledFont) {
gfxDevCrash(LogReason::InvalidFont) << "Invalid scaled font";
return;
}
AutoPrepareForDrawing prep(this, mContext);
AutoClearDeviceOffset clear(aPattern);
cairo_set_scaled_font(mContext, cairoScaledFont);
cairo_pattern_t* pat =
GfxPatternToCairoPattern(aPattern, aOptions.mAlpha, GetTransform());
if (!pat) return;
cairo_set_source(mContext, pat);
cairo_pattern_destroy(pat);
cairo_antialias_t aa = GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode);
cairo_set_antialias(mContext, aa);
// Override any font-specific options as necessary.
SetFontOptions(aa);
// Convert our GlyphBuffer into a vector of Cairo glyphs. This code can
// execute millions of times in short periods, so we want to avoid heap
// allocation whenever possible. So we use an inline vector capacity of 1024
// bytes (the maximum allowed by mozilla::Vector), which gives an inline
// length of 1024 / 24 = 42 elements, which is enough to typically avoid heap
// allocation in ~99% of cases.
Vector<cairo_glyph_t, 1024 / sizeof(cairo_glyph_t)> glyphs;
if (!glyphs.resizeUninitialized(aBuffer.mNumGlyphs)) {
gfxDevCrash(LogReason::GlyphAllocFailedCairo) << "glyphs allocation failed";
return;
}
for (uint32_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
glyphs[i].index = aBuffer.mGlyphs[i].mIndex;
glyphs[i].x = aBuffer.mGlyphs[i].mPosition.x;
glyphs[i].y = aBuffer.mGlyphs[i].mPosition.y;
}
if (!SupportsVariationSettings(mSurface) && aFont->HasVariationSettings() &&
StaticPrefs::print_font_variations_as_paths()) {
cairo_set_fill_rule(mContext, CAIRO_FILL_RULE_WINDING);
cairo_new_path(mContext);
cairo_glyph_path(mContext, &glyphs[0], aBuffer.mNumGlyphs);
cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);
cairo_fill(mContext);
} else {
cairo_show_glyphs(mContext, &glyphs[0], aBuffer.mNumGlyphs);
}
if (cairo_surface_status(cairo_get_group_target(mContext))) {
gfxDebug() << "Ending FillGlyphs with a bad surface "
<< cairo_surface_status(cairo_get_group_target(mContext));
}
}
void DrawTargetCairo::Mask(const Pattern& aSource, const Pattern& aMask,
const DrawOptions& aOptions /* = DrawOptions() */) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
AutoClearDeviceOffset clearSource(aSource);
AutoClearDeviceOffset clearMask(aMask);
cairo_set_antialias(mContext,
GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));
cairo_pattern_t* source =
GfxPatternToCairoPattern(aSource, aOptions.mAlpha, GetTransform());
if (!source) {
return;
}
cairo_pattern_t* mask =
GfxPatternToCairoPattern(aMask, aOptions.mAlpha, GetTransform());
if (!mask) {
cairo_pattern_destroy(source);
return;
}
if (cairo_pattern_status(source) || cairo_pattern_status(mask)) {
cairo_pattern_destroy(source);
cairo_pattern_destroy(mask);
gfxWarning() << "Invalid pattern";
return;
}
cairo_set_source(mContext, source);
cairo_set_operator(mContext, GfxOpToCairoOp(aOptions.mCompositionOp));
cairo_mask(mContext, mask);
cairo_pattern_destroy(mask);
cairo_pattern_destroy(source);
}
void DrawTargetCairo::MaskSurface(const Pattern& aSource, SourceSurface* aMask,
Point aOffset, const DrawOptions& aOptions) {
if (mTransformSingular) {
return;
}
AutoPrepareForDrawing prep(this, mContext);
AutoClearDeviceOffset clearSource(aSource);
AutoClearDeviceOffset clearMask(aMask);
if (!PatternIsCompatible(aSource)) {
return;
}
cairo_set_antialias(mContext,
GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));
cairo_pattern_t* pat =
GfxPatternToCairoPattern(aSource, aOptions.mAlpha, GetTransform());
if (!pat) {
return;
}
if (cairo_pattern_status(pat)) {
cairo_pattern_destroy(pat);
gfxWarning() << "Invalid pattern";
return;
}
cairo_set_source(mContext, pat);
if (NeedIntermediateSurface(aSource, aOptions)) {
cairo_push_group_with_content(mContext, CAIRO_CONTENT_COLOR_ALPHA);
// Don't want operators to be applied twice
cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);
// Now draw the content using the desired operator
cairo_paint_with_alpha(mContext, aOptions.mAlpha);
cairo_pop_group_to_source(mContext);
}
cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aMask);
if (!surf) {
cairo_pattern_destroy(pat);
return;
}
cairo_pattern_t* mask = cairo_pattern_create_for_surface(surf);
cairo_matrix_t matrix;
cairo_matrix_init_translate(&matrix, -aOffset.x - aMask->GetRect().x,
-aOffset.y - aMask->GetRect().y);
cairo_pattern_set_matrix(mask, &matrix);
cairo_set_operator(mContext, GfxOpToCairoOp(aOptions.mCompositionOp));
cairo_mask(mContext, mask);
cairo_surface_destroy(surf);
cairo_pattern_destroy(mask);
cairo_pattern_destroy(pat);
}
void DrawTargetCairo::PushClip(const Path* aPath) {
if (aPath->GetBackendType() != BackendType::CAIRO) {
return;
}
WillChange(aPath);
cairo_save(mContext);
PathCairo* path =
const_cast<PathCairo*>(static_cast<const PathCairo*>(aPath));
if (mTransformSingular) {
cairo_new_path(mContext);
cairo_rectangle(mContext, 0, 0, 0, 0);
} else {
path->SetPathOnContext(mContext);
}
cairo_clip_preserve(mContext);
}
void DrawTargetCairo::PushClipRect(const Rect& aRect) {
WillChange();
cairo_save(mContext);
cairo_new_path(mContext);
if (mTransformSingular) {
cairo_rectangle(mContext, 0, 0, 0, 0);
} else {
cairo_rectangle(mContext, aRect.X(), aRect.Y(), aRect.Width(),
aRect.Height());
}
cairo_clip_preserve(mContext);
}
void DrawTargetCairo::PopClip() {
// save/restore does not affect the path, so no need to call WillChange()
// cairo_restore will restore the transform too and we don't want to do that
// so we'll save it now and restore it after the cairo_restore
cairo_matrix_t mat;
cairo_get_matrix(mContext, &mat);
cairo_restore(mContext);
cairo_set_matrix(mContext, &mat);
}
void DrawTargetCairo::PushLayer(bool aOpaque, Float aOpacity,
SourceSurface* aMask,
const Matrix& aMaskTransform,
const IntRect& aBounds, bool aCopyBackground) {
cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;
if (mFormat == SurfaceFormat::A8) {
content = CAIRO_CONTENT_ALPHA;
} else if (aOpaque) {
content = CAIRO_CONTENT_COLOR;
}
if (aCopyBackground) {
cairo_surface_t* source = cairo_get_group_target(mContext);
cairo_push_group_with_content(mContext, content);
cairo_surface_t* dest = cairo_get_group_target(mContext);
cairo_t* ctx = cairo_create(dest);
cairo_set_source_surface(ctx, source, 0, 0);
cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
cairo_paint(ctx);
cairo_destroy(ctx);
} else {
cairo_push_group_with_content(mContext, content);
}
PushedLayer layer(aOpacity, mPermitSubpixelAA);
if (aMask) {
cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aMask);
if (surf) {
layer.mMaskPattern = cairo_pattern_create_for_surface(surf);
Matrix maskTransform = aMaskTransform;
maskTransform.PreTranslate(aMask->GetRect().X(), aMask->GetRect().Y());
cairo_matrix_t mat;
GfxMatrixToCairoMatrix(maskTransform, mat);
cairo_matrix_invert(&mat);
cairo_pattern_set_matrix(layer.mMaskPattern, &mat);
cairo_surface_destroy(surf);
} else {
gfxCriticalError() << "Failed to get cairo surface for mask surface!";
}
}
mPushedLayers.push_back(layer);
SetPermitSubpixelAA(aOpaque);
}
void DrawTargetCairo::PopLayer() {
MOZ_ASSERT(mPushedLayers.size());
cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);
cairo_pop_group_to_source(mContext);
PushedLayer layer = mPushedLayers.back();
mPushedLayers.pop_back();
if (!layer.mMaskPattern) {
cairo_paint_with_alpha(mContext, layer.mOpacity);
} else {
if (layer.mOpacity != Float(1.0)) {
cairo_push_group_with_content(mContext, CAIRO_CONTENT_COLOR_ALPHA);
// Now draw the content using the desired operator
cairo_paint_with_alpha(mContext, layer.mOpacity);
cairo_pop_group_to_source(mContext);
}
cairo_mask(mContext, layer.mMaskPattern);
}
cairo_matrix_t mat;
GfxMatrixToCairoMatrix(mTransform, mat);
cairo_set_matrix(mContext, &mat);
cairo_pattern_destroy(layer.mMaskPattern);
SetPermitSubpixelAA(layer.mWasPermittingSubpixelAA);
}
already_AddRefed<PathBuilder> DrawTargetCairo::CreatePathBuilder(
FillRule aFillRule /* = FillRule::FILL_WINDING */) const {
return MakeAndAddRef<PathBuilderCairo>(aFillRule);
}
void DrawTargetCairo::ClearSurfaceForUnboundedSource(
const CompositionOp& aOperator) {
if (aOperator != CompositionOp::OP_SOURCE) return;
cairo_set_operator(mContext, CAIRO_OPERATOR_CLEAR);
// It doesn't really matter what the source is here, since Paint
// isn't bounded by the source and the mask covers the entire clip
// region.
cairo_paint(mContext);
}
already_AddRefed<GradientStops> DrawTargetCairo::CreateGradientStops(
GradientStop* aStops, uint32_t aNumStops, ExtendMode aExtendMode) const {
return MakeAndAddRef<GradientStopsCairo>(aStops, aNumStops, aExtendMode);
}
already_AddRefed<FilterNode> DrawTargetCairo::CreateFilter(FilterType aType) {
return FilterNodeSoftware::Create(aType);
}
already_AddRefed<SourceSurface> DrawTargetCairo::CreateSourceSurfaceFromData(
unsigned char* aData, const IntSize& aSize, int32_t aStride,
SurfaceFormat aFormat) const {
if (!aData) {
gfxWarning() << "DrawTargetCairo::CreateSourceSurfaceFromData null aData";
return nullptr;
}
cairo_surface_t* surf =
CopyToImageSurface(aData, IntRect(IntPoint(), aSize), aStride, aFormat);
if (!surf) {
return nullptr;
}
RefPtr<SourceSurfaceCairo> source_surf =
new SourceSurfaceCairo(surf, aSize, aFormat);
cairo_surface_destroy(surf);
return source_surf.forget();
}
#ifdef CAIRO_HAS_XLIB_SURFACE
static cairo_user_data_key_t gDestroyPixmapKey;
struct DestroyPixmapClosure {
DestroyPixmapClosure(Drawable d, Screen* s) : mPixmap(d), mScreen(s) {}
~DestroyPixmapClosure() { XFreePixmap(DisplayOfScreen(mScreen), mPixmap); }
Drawable mPixmap;
Screen* mScreen;
};
static void DestroyPixmap(void* data) {
delete static_cast<DestroyPixmapClosure*>(data);
}
#endif
already_AddRefed<SourceSurface> DrawTargetCairo::OptimizeSourceSurface(
SourceSurface* aSurface) const {
RefPtr<SourceSurface> surface(aSurface);
#ifdef CAIRO_HAS_XLIB_SURFACE
cairo_surface_type_t ctype = cairo_surface_get_type(mSurface);
if (aSurface->GetType() == SurfaceType::CAIRO &&
cairo_surface_get_type(
static_cast<SourceSurfaceCairo*>(aSurface)->GetSurface()) == ctype) {
return surface.forget();
}
if (ctype != CAIRO_SURFACE_TYPE_XLIB) {
return surface.forget();
}
IntSize size = aSurface->GetSize();
if (!size.width || !size.height) {
return surface.forget();
}
// Although the dimension parameters in the xCreatePixmapReq wire protocol are
// 16-bit unsigned integers, the server's CreatePixmap returns BadAlloc if
// either dimension cannot be represented by a 16-bit *signed* integer.
# define XLIB_IMAGE_SIDE_SIZE_LIMIT 0x7fff
if (size.width > XLIB_IMAGE_SIDE_SIZE_LIMIT ||