By default T-trace is disabled in the build.
Use --enable-ttrace=yes for enabling the same.
Change-Id: I697c0a3f05bc9010620db563a4121c2ed0e46599
Signed-off-by: hk57.kim <hk57.kim@samsung.com>
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_trace_sources)
endif
+all_cairo_boilerplate_private += $(cairo_boilerplate_ttrace_private) $(cairo_boilerplate_ttrace_headers)
+all_cairo_boilerplate_cxx_sources += $(cairo_boilerplate_ttrace_cxx_sources)
+all_cairo_boilerplate_sources += $(cairo_boilerplate_ttrace_sources)
+ifeq ($(CAIRO_HAS_TTRACE),1)
+enabled_cairo_boilerplate_private += $(cairo_boilerplate_ttrace_private) $(cairo_boilerplate_ttrace_headers)
+enabled_cairo_boilerplate_cxx_sources += $(cairo_boilerplate_ttrace_cxx_sources)
+enabled_cairo_boilerplate_sources += $(cairo_boilerplate_ttrace_sources)
+endif
+
all_cairo_boilerplate_private += $(cairo_boilerplate_interpreter_private) $(cairo_boilerplate_interpreter_headers)
all_cairo_boilerplate_cxx_sources += $(cairo_boilerplate_interpreter_cxx_sources)
all_cairo_boilerplate_sources += $(cairo_boilerplate_interpreter_sources)
CAIRO_HAS_PTHREAD=0
CAIRO_HAS_GOBJECT_FUNCTIONS=0
CAIRO_HAS_TRACE=0
+CAIRO_HAS_TTRACE=0
CAIRO_HAS_INTERPRETER=1
CAIRO_HAS_SYMBOL_LOOKUP=0
ifeq ($(CAIRO_HAS_TRACE),1)
@echo "#define CAIRO_HAS_TRACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
+ifeq ($(CAIRO_HAS_TTRACE),1)
+ @echo "#define CAIRO_HAS_TTRACE 1" >> $(top_srcdir)/src/cairo-features.h
+endif
ifeq ($(CAIRO_HAS_INTERPRETER),1)
@echo "#define CAIRO_HAS_INTERPRETER 1" >> $(top_srcdir)/src/cairo-features.h
endif
echo ""
echo "The following features and utilities:"
echo " cairo-trace: $use_trace"
+ echo " cairo-ttrace: $use_ttrace"
echo " cairo-script-interpreter: $use_interpreter"
echo ""
echo "And the following internal features:"
[have_libz="no (requires zlib http://www.gzip.org/zlib/)"])],
[have_libz="no (requires zlib http://www.gzip.org/zlib/)"])
+AC_CHECK_LIB(ttrace, traceBegin,
+ [AC_CHECK_HEADER(ttrace.h, [
+ have_ttrace=yes
+ AC_DEFINE(HAVE_TTRACE, 1, [Define to 1 if you have ttrace available])
+ ttrace_LIBS="-lttrace"
+ ],
+ [have_ttrace="no (requires ttrace)"])],
+ [have_ttrace="no (requires ttraec)"])
+LIBS="$ttrace_LIBS $LIBS"
+
AC_CHECK_LIB(wayland-client, wl_display_connect,
[AC_CHECK_HEADER(wayland-client.h, [
have_wayland=yes
fi
])
+CAIRO_ENABLE(ttrace, cairo-ttrace, no, [
+ if test "x$have_ttrace" != "xyes"; then
+ use_ttrace="no (requires ttrace)"
+ fi
+])
+
CAIRO_ENABLE(interpreter, cairo-script-interpreter, yes, [
if test "x$have_libz" != "xyes"; then
use_interpreter="no (requires zlib)"
BuildRequires: which
BuildRequires: pkgconfig(ecore)
BuildRequires: pkgconfig(evas)
+BuildRequires: pkgconfig(ttrace)
%if %{with cairo_gl_backend}
%if %{with x} && %{with desktop}
BuildRequires: pkgconfig(gl)
--enable-script=yes \
--enable-svg=yes \
--enable-tee=no \
+ --enable-ttrace=no \
%if %{with wayland} && !%{with x}
--disable-xlib \
--disable-xcb \
enabled_cairo_sources += $(cairo_trace_sources)
endif
+all_cairo_private += $(cairo_ttrace_private) $(cairo_ttrace_headers)
+all_cairo_cxx_sources += $(cairo_ttrace_cxx_sources)
+all_cairo_sources += $(cairo_ttrace_sources)
+ifeq ($(CAIRO_HAS_TTRACE),1)
+enabled_cairo_private += $(cairo_ttrace_private) $(cairo_ttrace_headers)
+enabled_cairo_cxx_sources += $(cairo_ttrace_cxx_sources)
+enabled_cairo_sources += $(cairo_ttrace_sources)
+endif
+
all_cairo_private += $(cairo_interpreter_private) $(cairo_interpreter_headers)
all_cairo_cxx_sources += $(cairo_interpreter_cxx_sources)
all_cairo_sources += $(cairo_interpreter_sources)
#include "cairo-compositor-private.h"
#include "cairo-damage-private.h"
#include "cairo-error-private.h"
+#include "cairo-ttrace.h"
cairo_int_status_t
_cairo_compositor_paint (const cairo_compositor_t *compositor,
const cairo_pattern_t *source,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_composite_rectangles_t extents;
cairo_int_status_t status;
cairo_bool_t initialized = TRUE;
surface,
op, source,
clip);
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
do {
while (compositor->paint == NULL)
clip);
initialized = TRUE;
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
}
status = compositor->paint (compositor, &extents);
_cairo_composite_rectangles_fini (&extents);
+ CAIRO_TRACE_END (__func__);
return status;
}
const cairo_pattern_t *mask,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_composite_rectangles_t extents;
cairo_int_status_t status;
cairo_bool_t initialized = TRUE;
surface,
op, source,
mask, clip);
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
do {
while (compositor->mask == NULL)
mask, clip);
initialized = TRUE;
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
}
status = compositor->mask (compositor, &extents);
_cairo_composite_rectangles_fini (&extents);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_composite_rectangles_t extents;
cairo_int_status_t status;
cairo_bool_t initialized = TRUE;
TRACE ((stderr, "%s\n", __FUNCTION__));
- if (_cairo_pen_vertices_needed (tolerance, style->line_width/2, ctm) <= 1)
- return CAIRO_INT_STATUS_NOTHING_TO_DO;
+ if (_cairo_pen_vertices_needed (tolerance, style->line_width/2, ctm) <= 1) {
+ CAIRO_TRACE_END (__func__);
+ return CAIRO_INT_STATUS_NOTHING_TO_DO;
+ }
if (compositor->lazy_init) {
status = _cairo_composite_rectangles_lazy_init_for_stroke (&extents,
op, source,
path, style,
ctm, clip);
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
do {
while (compositor->stroke == NULL)
clip);
initialized = TRUE;
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
}
status = compositor->stroke (compositor, &extents,
_cairo_composite_rectangles_fini (&extents);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_composite_rectangles_t extents;
cairo_int_status_t status;
cairo_bool_t initialized = TRUE;
surface,
op, source,
path, clip);
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
do {
while (compositor->fill == NULL)
path, clip);
initialized = TRUE;
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
}
status = compositor->fill (compositor, &extents,
_cairo_composite_rectangles_fini (&extents);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_scaled_font_t *scaled_font,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_composite_rectangles_t extents;
cairo_bool_t overlap;
cairo_int_status_t status;
scaled_font,
glyphs, num_glyphs,
clip, &overlap);
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
do {
while (compositor->glyphs == NULL)
clip, &overlap);
initialized = TRUE;
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
}
status = compositor->glyphs (compositor, &extents,
_cairo_composite_rectangles_fini (&extents);
+ CAIRO_TRACE_END (__func__);
return status;
}
#include "cairo-freed-pool-private.h"
#include "cairo-path-private.h"
#include "cairo-pattern-private.h"
+#include "cairo-ttrace.h"
#define CAIRO_TOLERANCE_MINIMUM _cairo_fixed_to_double(1)
static void
_cairo_default_context_destroy (void *abstract_cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_default_context_t *cr = abstract_cr;
_cairo_default_context_fini (cr);
/* mark the context as invalid to protect against misuse */
cr->base.status = CAIRO_STATUS_NULL_POINTER;
_freed_pool_put (&context_pool, cr);
+ CAIRO_TRACE_END (__func__);
}
static cairo_surface_t *
static cairo_status_t
_cairo_default_context_set_source_rgba (void *abstract_cr, double red, double green, double blue, double alpha)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_default_context_t *cr = abstract_cr;
cairo_pattern_t *pattern;
cairo_status_t status;
if (_current_source_matches_solid (cr->gstate->source,
- red, green, blue, alpha))
- return CAIRO_STATUS_SUCCESS;
+ red, green, blue, alpha)) {
+ CAIRO_TRACE_END (__func__);
+ return CAIRO_STATUS_SUCCESS;
+ }
/* push the current pattern to the freed lists */
_cairo_default_context_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
pattern = cairo_pattern_create_rgba (red, green, blue, alpha);
- if (unlikely (pattern->status))
- return pattern->status;
+ if (unlikely (pattern->status)) {
+ status = pattern->status;
+ cairo_pattern_destroy (pattern);
+ CAIRO_TRACE_END (__func__);
+ return pattern->status;
+ }
status = _cairo_default_context_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
+ CAIRO_TRACE_END (__func__);
return status;
}
_cairo_default_context_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
pattern = cairo_pattern_create_for_surface (surface);
- if (unlikely (pattern->status))
- return pattern->status;
+ if (unlikely (pattern->status)) {
+ status = pattern->status;
+ cairo_pattern_destroy (pattern);
+ return status;
+ }
cairo_matrix_init_translate (&matrix, -x, -y);
cairo_pattern_set_matrix (pattern, &matrix);
static cairo_status_t
_cairo_default_context_paint (void *abstract_cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_default_context_t *cr = abstract_cr;
- return _cairo_gstate_paint (cr->gstate);
+ cairo_status_t status = _cairo_gstate_paint (cr->gstate);
+ CAIRO_TRACE_END (__func__);
+ return status;
}
static cairo_status_t
{
cairo_default_context_t *cr = abstract_cr;
cairo_status_t status;
-
+
status = _cairo_gstate_fill (cr->gstate, cr->path);
if (unlikely (status))
return status;
cairo_t *
_cairo_default_context_create (void *target)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_default_context_t *cr;
cairo_status_t status;
cr = _freed_pool_get (&context_pool);
if (unlikely (cr == NULL)) {
- cr = malloc (sizeof (cairo_default_context_t));
- if (unlikely (cr == NULL))
- return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
- }
+ cr = malloc (sizeof (cairo_default_context_t));
+ if (unlikely (cr == NULL)) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ }
+ }
status = _cairo_default_context_init (cr, target);
if (unlikely (status)) {
- _freed_pool_put (&context_pool, cr);
- return _cairo_create_in_error (status);
+ _freed_pool_put (&context_pool, cr);
+ CAIRO_TRACE_END (__func__);
+ return _cairo_create_in_error (status);
}
+ CAIRO_TRACE_END (__func__);
return &cr->base;
}
#include "cairo-device-private.h"
#include "cairo-error-private.h"
#include "cairo-list-inline.h"
+#include "cairo-ttrace.h"
/**
* SECTION:cairo-device
_cairo_device_init (cairo_device_t *device,
const cairo_device_backend_t *backend)
{
+ CAIRO_TRACE_BEGIN (__func__);
CAIRO_REFERENCE_COUNT_INIT (&device->ref_count, 1);
device->status = CAIRO_STATUS_SUCCESS;
cairo_list_init (&device->shadow_caches);
device->shadow_caches_size = 0;
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_device_destroy (cairo_device_t *device)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_user_data_array_t user_data;
if (device == NULL ||
CAIRO_REFERENCE_COUNT_IS_INVALID (&device->ref_count))
{
- return;
+ CAIRO_TRACE_END (__func__);
+ return;
}
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&device->ref_count));
- if (! _cairo_reference_count_dec_and_test (&device->ref_count))
- return;
+ if (! _cairo_reference_count_dec_and_test (&device->ref_count)) {
+ CAIRO_TRACE_END (__func__);
+ return;
+ }
while (! cairo_list_is_empty (&device->shadow_caches)) {
cairo_shadow_cache_t *shadow;
- shadow = cairo_list_first_entry (&device->shadow_caches,
+ shadow = cairo_list_first_entry (&device->shadow_caches,
cairo_shadow_cache_t,
link);
device->backend->destroy (device);
_cairo_user_data_array_fini (&user_data);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_device_destroy);
#include "cairo-gl-private.h"
#include "cairo-error-private.h"
+#include "cairo-ttrace.h"
#if CAIRO_HAS_EVASGL_SURFACE && CAIRO_HAS_GLESV2_SURFACE
extern void glActiveTexture (GLenum texture);
_egl_swap_buffers (void *abstract_ctx,
cairo_gl_surface_t *abstract_surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_egl_context_t *ctx = abstract_ctx;
cairo_egl_surface_t *surface = (cairo_egl_surface_t *) abstract_surface;
eglSwapBuffers (ctx->display, surface->egl);
+ CAIRO_TRACE_END (__func__);
}
static void
_egl_destroy (void *abstract_ctx)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_egl_context_t *ctx = abstract_ctx;
eglMakeCurrent (ctx->display,
EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (ctx->dummy_surface != EGL_NO_SURFACE)
eglDestroySurface (ctx->display, ctx->dummy_surface);
+ CAIRO_TRACE_END (__func__);
}
static cairo_bool_t
cairo_device_t *
cairo_egl_device_create (EGLDisplay dpy, EGLContext egl)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_egl_context_t *ctx;
cairo_status_t status;
int attribs[] = {
EGLint numConfigs;
ctx = calloc (1, sizeof (cairo_egl_context_t));
- if (unlikely (ctx == NULL))
- return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
+ if (unlikely (ctx == NULL)) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
+ }
ctx->display = dpy;
ctx->context = egl;
ctx->dummy_surface = eglCreatePbufferSurface (dpy, config, attribs);
if (ctx->dummy_surface == NULL) {
free (ctx);
+ CAIRO_TRACE_END (__func__);
return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
}
if (!eglMakeCurrent (dpy, ctx->dummy_surface, ctx->dummy_surface, egl)) {
free (ctx);
+ CAIRO_TRACE_END (__func__);
return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
}
}
status = _cairo_gl_dispatch_init (&ctx->base.dispatch,
_cairo_egl_get_proc_address, NULL);
if (unlikely (status)) {
- free (ctx);
- return _cairo_gl_context_create_in_error (status);
+ free (ctx);
+ CAIRO_TRACE_END (__func__);
+ return _cairo_gl_context_create_in_error (status);
}
status = _cairo_gl_context_init (&ctx->base);
if (unlikely (status)) {
- if (ctx->dummy_surface != EGL_NO_SURFACE)
- eglDestroySurface (dpy, ctx->dummy_surface);
- free (ctx);
- return _cairo_gl_context_create_in_error (status);
+ if (ctx->dummy_surface != EGL_NO_SURFACE)
+ eglDestroySurface (dpy, ctx->dummy_surface);
+ free (ctx);
+ CAIRO_TRACE_END (__func__);
+ return _cairo_gl_context_create_in_error (status);
}
/* Tune the default VBO size to reduce overhead on embedded devices.
ctx->current_surface = EGL_NO_SURFACE;
+ CAIRO_TRACE_END (__func__);
return &ctx->base.base;
}
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_egl_surface_t *surface;
- if (unlikely (device->status))
- return _cairo_surface_create_in_error (device->status);
+ if (unlikely (device->status)) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_surface_create_in_error (device->status);
+ }
- if (device->backend->type != CAIRO_DEVICE_TYPE_GL)
- return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
+ if (device->backend->type != CAIRO_DEVICE_TYPE_GL) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
+ }
- if (width <= 0 || height <= 0)
+ if (width <= 0 || height <= 0) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
+ }
surface = calloc (1, sizeof (cairo_egl_surface_t));
- if (unlikely (surface == NULL))
- return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ }
_cairo_gl_surface_init (device, &surface->base,
CAIRO_CONTENT_COLOR_ALPHA, width, height);
surface->egl = egl;
+ CAIRO_TRACE_END (__func__);
return &surface->base.base;
}
#include "cairo-clip-private.h"
#include "cairo-error-private.h"
#include "cairo-image-surface-private.h"
+#include "cairo-ttrace.h"
cairo_int_status_t
_cairo_gl_composite_set_source (cairo_gl_composite_t *setup,
_cairo_gl_operand_copy (&setup->src, source);
if (source->type == CAIRO_GL_OPERAND_TEXTURE ||
source->type == CAIRO_GL_OPERAND_GAUSSIAN)
- status = _cairo_gl_surface_resolve_multisampling (source->texture.surface);
+ status = _cairo_gl_surface_resolve_multisampling (source->texture.surface);
}
void
_cairo_gl_operand_copy (&setup->mask, mask);
if (mask->type == CAIRO_GL_OPERAND_TEXTURE ||
mask->type == CAIRO_GL_OPERAND_GAUSSIAN)
- status = _cairo_gl_surface_resolve_multisampling (mask->texture.surface);
+ status = _cairo_gl_surface_resolve_multisampling (mask->texture.surface);
}
}
_cairo_gl_composite_begin (cairo_gl_composite_t *setup,
cairo_gl_context_t **ctx_out)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_context_t *ctx;
cairo_status_t status;
assert (setup->dst);
status = _cairo_gl_context_acquire (setup->dst->base.device, &ctx);
- if (unlikely (status))
- return status;
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
setup->dst->content_cleared = FALSE;
if (unlikely (status))
status = _cairo_gl_context_release (ctx, status);
+ CAIRO_TRACE_END (__func__);
return status;
}
static inline void
_cairo_gl_composite_draw_tristrip (cairo_gl_context_t *ctx)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_array_t* indices = &ctx->tristrip_indices;
const unsigned short *indices_array = _cairo_array_index_const (indices, 0);
ctx->dispatch.DrawElements (GL_TRIANGLE_STRIP, _cairo_array_num_elements (indices), GL_UNSIGNED_SHORT, ctx->ibo ? 0 :indices_array);
_cairo_array_truncate (indices, 0);
+ CAIRO_TRACE_END (__func__);
}
static inline void
_cairo_gl_composite_draw_line (cairo_gl_context_t *ctx)
{
+ CAIRO_TRACE_BEGIN (__func__);
GLenum type = GL_LINE_STRIP;
cairo_array_t* indices = &ctx->tristrip_indices;
const unsigned short *indices_array = _cairo_array_index_const (indices, 0);
ctx->dispatch.DrawElements (type, _cairo_array_num_elements (indices), GL_UNSIGNED_SHORT, ctx->ibo ? 0 : indices_array);
_cairo_array_truncate (indices, 0);
+ CAIRO_TRACE_END (__func__);
}
static inline void
_cairo_gl_composite_draw_triangles (cairo_gl_context_t *ctx,
unsigned int count)
{
+ CAIRO_TRACE_BEGIN (__func__);
if (! ctx->pre_shader) {
ctx->dispatch.DrawArrays (GL_TRIANGLES, 0, count);
} else {
_cairo_gl_set_operator (ctx, CAIRO_OPERATOR_ADD, TRUE);
ctx->dispatch.DrawArrays (GL_TRIANGLES, 0, count);
}
+ CAIRO_TRACE_END (__func__);
}
static void
_cairo_gl_composite_draw_triangles_with_clip_region (cairo_gl_context_t *ctx,
unsigned int count)
{
+ CAIRO_TRACE_BEGIN (__func__);
int i, num_rectangles;
if (!ctx->clip_region) {
- _cairo_gl_composite_draw_triangles (ctx, count);
- return;
+ _cairo_gl_composite_draw_triangles (ctx, count);
+ CAIRO_TRACE_END (__func__);
+ return;
}
num_rectangles = cairo_region_num_rectangles (ctx->clip_region);
_enable_scissor_buffer (ctx);
_cairo_gl_composite_draw_triangles (ctx, count);
}
+ CAIRO_TRACE_END (__func__);
}
static void
void
_cairo_gl_composite_flush (cairo_gl_context_t *ctx)
{
+ CAIRO_TRACE_BEGIN (__func__);
unsigned int count;
int i;
- if (_cairo_gl_context_is_flushed (ctx))
+ if (_cairo_gl_context_is_flushed (ctx)) {
+ CAIRO_TRACE_END (__func__);
return;
-
- /* ensure we are binding to vbo and ibo */
- _cairo_gl_ensure_drawbuffers (ctx);
+ }
count = ctx->vb_offset / ctx->vertex_size;
_cairo_gl_glyph_cache_unlock (&ctx->glyph_cache[i]);
_cairo_gl_image_cache_unlock (ctx);
+ CAIRO_TRACE_END (__func__);
}
static void
cairo_gl_surface_t *dst,
cairo_bool_t assume_component_alpha)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
memset (setup, 0, sizeof (cairo_gl_composite_t));
status = _cairo_gl_composite_set_operator (setup, op,
assume_component_alpha);
- if (status)
- return status;
+ if (status) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
setup->dst = dst;
setup->clip_region = dst->clip_region;
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
#include "cairo-error-private.h"
#include "cairo-gl-private.h"
#include "cairo-rtree-private.h"
+#include "cairo-ttrace.h"
#if CAIRO_HAS_EVASGL_SURFACE
#include "cairo-evas-gl.h"
cairo_status_t
_cairo_gl_context_init (cairo_gl_context_t *ctx)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
cairo_gl_dispatch_t *dispatch = &ctx->dispatch;
int gl_version = _cairo_gl_get_version (dispatch);
cairo_list_init (&ctx->fonts);
/* Support only GL version >= 1.3 */
- if (gl_version < CAIRO_GL_VERSION_ENCODE (1, 3))
- return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ if (gl_version < CAIRO_GL_VERSION_ENCODE (1, 3)) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ }
/* Check for required extensions */
if (is_desktop) {
} else if (_cairo_gl_has_extension (&ctx->dispatch, "GL_ARB_texture_rectangle")) {
ctx->tex_target = GL_TEXTURE_RECTANGLE;
ctx->has_npot_repeat = FALSE;
- } else
+ } else {
+ CAIRO_TRACE_END (__func__);
return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ }
} else {
ctx->tex_target = GL_TEXTURE_2D;
if (_cairo_gl_has_extension (&ctx->dispatch, "GL_OES_texture_npot") ||
}
if (is_desktop && gl_version < CAIRO_GL_VERSION_ENCODE (2, 1) &&
- ! _cairo_gl_has_extension (&ctx->dispatch, "GL_ARB_pixel_buffer_object"))
- return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ ! _cairo_gl_has_extension (&ctx->dispatch, "GL_ARB_pixel_buffer_object")) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ }
- if (is_gles && ! _cairo_gl_has_extension (&ctx->dispatch, "GL_EXT_texture_format_BGRA8888"))
- return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ if (is_gles && ! _cairo_gl_has_extension (&ctx->dispatch, "GL_EXT_texture_format_BGRA8888")) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
+ }
ctx->has_map_buffer =
is_desktop || (is_gles && _cairo_gl_has_extension (&ctx->dispatch, "GL_OES_mapbuffer"));
ctx->gl_flavor = gl_flavor;
status = _cairo_gl_context_init_shaders (ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_cache_init (&ctx->gradients,
_cairo_gl_gradient_equal,
NULL,
(cairo_destroy_func_t) _cairo_gl_gradient_destroy,
CAIRO_GL_GRADIENT_CACHE_SIZE);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
ctx->vbo_size = _cairo_gl_get_vbo_size();
ctx->vb = malloc (ctx->vbo_size);
if (unlikely (ctx->vb == NULL)) {
- _cairo_cache_fini (&ctx->gradients);
- ctx->dispatch.DeleteVertexArrays (1, &ctx->vao);
- ctx->dispatch.DeleteBuffers (1, &ctx->vbo);
- ctx->dispatch.DeleteBuffers (1, &ctx->ibo);
- return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ _cairo_cache_fini (&ctx->gradients);
+ ctx->dispatch.DeleteVertexArrays (1, &ctx->vao);
+ ctx->dispatch.DeleteBuffers (1, &ctx->vbo);
+ ctx->dispatch.DeleteBuffers (1, &ctx->ibo);
+ CAIRO_TRACE_END (__func__);
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
ctx->primitive_type = CAIRO_GL_PRIMITIVE_TYPE_TRIANGLES;
_cairo_gl_context_reset (ctx);
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
_cairo_gl_clear_framebuffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
if (ctx->gl_flavor == CAIRO_GL_FLAVOR_DESKTOP)
return;
_disable_stencil_buffer (ctx);
ctx->dispatch.Clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
+ CAIRO_TRACE_END (__func__);
}
#if CAIRO_HAS_GLESV2_SURFACE || CAIRO_HAS_EVASGL_SURFACE
_cairo_gl_ensure_msaa_gles_framebuffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
- if (ctx->has_angle_multisampling)
- return;
+ CAIRO_TRACE_BEGIN (__func__);
+ if (ctx->has_angle_multisampling) {
+ CAIRO_TRACE_END (__func__);
+ return;
+ }
- if (surface->msaa_active)
- return;
+ if (surface->msaa_active) {
+ CAIRO_TRACE_END (__func__);
+ return;
+ }
ctx->dispatch.FramebufferTexture2DMultisample(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
/* From now on MSAA will always be active on this surface. */
surface->msaa_active = TRUE;
+ CAIRO_TRACE_END (__func__);
}
#endif
_cairo_gl_ensure_framebuffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
GLenum status;
cairo_gl_dispatch_t *dispatch = &ctx->dispatch;
- if (likely (surface->fb))
+ if (likely (surface->fb)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
/* Create a framebuffer object wrapping the texture so that we can render
* to it.
"destination is framebuffer incomplete: %s [%#x]\n",
str, status);
}
+ CAIRO_TRACE_END (__func__);
}
static void
_cairo_gl_ensure_multisampling (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
GLenum rgba;
if (ctx->gl_flavor == CAIRO_GL_FLAVOR_ES2 &&
- ! ctx->has_angle_multisampling)
- return;
-
+ ! ctx->has_angle_multisampling) {
+ CAIRO_TRACE_END (__func__);
+ return;
+ }
assert (surface->supports_msaa);
- if (surface->msaa_fb)
- return;
+ if (surface->msaa_fb) {
+ CAIRO_TRACE_END (__func__);
+ return;
+ }
/* We maintain a separate framebuffer for multisampling operations.
This allows us to do a fast paint to the non-multisampling framebuffer
surface->msaa_rb = 0;
ctx->dispatch.DeleteRenderbuffers (1, &surface->msaa_fb);
surface->msaa_fb = 0;
+ CAIRO_TRACE_END (__func__);
return;
}
memset (&ctx->states_cache.clear_red, 0, sizeof (GLclampf) * 4);
ctx->dispatch.Clear (GL_COLOR_BUFFER_BIT);
-
+ CAIRO_TRACE_END (__func__);
}
static cairo_bool_t
_cairo_gl_ensure_msaa_depth_stencil_buffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_dispatch_t *dispatch = &ctx->dispatch;
- if (surface->msaa_depth_stencil)
- return TRUE;
+ if (surface->msaa_depth_stencil) {
+ CAIRO_TRACE_END (__func__);
+ return TRUE;
+ }
//_cairo_gl_ensure_framebuffer (ctx, surface);
if (dispatch->CheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
dispatch->DeleteRenderbuffers (1, &surface->msaa_depth_stencil);
surface->msaa_depth_stencil = 0;
+ CAIRO_TRACE_END (__func__);
return FALSE;
}
+ CAIRO_TRACE_END (__func__);
return TRUE;
}
_cairo_gl_ensure_depth_stencil_buffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_dispatch_t *dispatch = &ctx->dispatch;
- if (surface->depth_stencil)
+ if (surface->depth_stencil) {
+ CAIRO_TRACE_END (__func__);
return TRUE;
+ }
_cairo_gl_ensure_framebuffer (ctx, surface);
if (dispatch->CheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
dispatch->DeleteRenderbuffers (1, &surface->depth_stencil);
surface->depth_stencil = 0;
+ CAIRO_TRACE_END (__func__);
return FALSE;
}
+ CAIRO_TRACE_END (__func__);
return TRUE;
}
bind_multisample_framebuffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
#if CAIRO_HAS_GL_SURFACE || CAIRO_HAS_EVASGL_SURFACE
cairo_bool_t stencil_test_enabled = FALSE, scissor_test_enabled = FALSE;
cairo_bool_t has_stencil_cache = FALSE;
#endif
ctx->dispatch.BindFramebuffer (GL_FRAMEBUFFER, surface->msaa_fb);
+ CAIRO_TRACE_END (__func__);
return;
}
_enable_scissor_buffer (ctx);
}
#endif
+ CAIRO_TRACE_END (__func__);
}
static void
bind_singlesample_framebuffer (cairo_gl_context_t *ctx,
cairo_gl_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_bool_t has_stencil_cache = surface->clip_on_stencil_buffer ? TRUE : FALSE;
cairo_bool_t stencil_test_enabled;
cairo_bool_t scissor_test_enabled;
GLbitfield mask = GL_COLOR_BUFFER_BIT;
if (ctx->gl_flavor == CAIRO_GL_FLAVOR_ES2 &&
- ! ctx->has_angle_multisampling)
+ ! ctx->has_angle_multisampling) {
+ CAIRO_TRACE_END (__func__);
return;
-
+ }
+
_cairo_gl_ensure_framebuffer (ctx, surface);
if (! surface->msaa_active) {
ctx->dispatch.Disable (GL_MULTISAMPLE);
#endif
ctx->dispatch.BindFramebuffer (GL_FRAMEBUFFER, surface->fb);
+ CAIRO_TRACE_END (__func__);
return;
}
_enable_stencil_buffer (ctx);
if (scissor_test_enabled)
_enable_scissor_buffer (ctx);
+ CAIRO_TRACE_END (__func__);
}
void
cairo_gl_surface_t *surface,
cairo_bool_t multisampling)
{
+ CAIRO_TRACE_BEGIN (__func__);
if (_cairo_gl_surface_is_texture (surface)) {
/* OpenGL ES surfaces only have either a multisample framebuffer or a
* singlesample framebuffer, so we cannot switch back and forth. */
_cairo_gl_ensure_framebuffer (ctx, surface);
ctx->dispatch.BindFramebuffer (GL_FRAMEBUFFER, surface->fb);
_cairo_gl_clear_framebuffer (ctx, surface);
+ CAIRO_TRACE_END (__func__);
return;
}
if (ctx->gl_flavor != CAIRO_GL_FLAVOR_DESKTOP && multisampling)
_cairo_gl_clear_framebuffer (ctx, surface);
+ CAIRO_TRACE_END (__func__);
}
void
cairo_gl_surface_t *surface,
cairo_bool_t multisampling)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_bool_t changing_surface, changing_sampling;
/* The decision whether or not to use multisampling happens when
if (! changing_surface && ! changing_sampling) {
if (surface->needs_update)
_cairo_gl_composite_flush (ctx);
+ CAIRO_TRACE_END (__func__);
return;
}
if (! changing_surface) {
_cairo_gl_composite_flush (ctx);
_cairo_gl_context_bind_framebuffer (ctx, surface, multisampling);
+ CAIRO_TRACE_END (__func__);
return;
}
else
_gl_identity_ortho (ctx->modelviewprojection_matrix,
0, surface->width, surface->height, 0);
+ CAIRO_TRACE_END (__func__);
}
void
#include "cairo-path-private.h"
#include "cairo-traps-private.h"
#include "cairo-convex-fill-private.h"
+#include "cairo-ttrace.h"
static cairo_bool_t
can_use_msaa_compositor (cairo_gl_surface_t *surface,
cairo_gl_composite_t *setup,
cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_traps_t traps;
status = _clip_to_traps (clip, &traps);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _draw_traps (ctx, setup, &traps);
_cairo_traps_fini (&traps);
+ CAIRO_TRACE_END (__func__);
return status;
}
_cairo_gl_msaa_compositor_mask_source_operator (const cairo_compositor_t *compositor,
cairo_composite_rectangles_t *composite)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_composite_t setup;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *) composite->surface;
cairo_gl_context_t *ctx = NULL;
status = _clip_to_traps (clip, &traps);
if (unlikely (status)) {
_cairo_traps_fini (&traps);
+ CAIRO_TRACE_END (__func__);
return status;
}
}
if (! is_pixel_aligned) {
status = _blit_texture_to_renderbuffer (dst);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
}
status = _cairo_gl_composite_init (&setup,
CAIRO_OPERATOR_DEST_OUT,
dst,
FALSE /* assume_component_alpha */);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_gl_composite_set_source (&setup,
composite->original_mask_pattern,
&composite->mask_sample_area,
if (clip)
_cairo_traps_fini (&traps);
+ CAIRO_TRACE_END (__func__);
return status;
}
_cairo_gl_msaa_compositor_mask (const cairo_compositor_t *compositor,
cairo_composite_rectangles_t *composite)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_composite_t setup;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *) composite->surface;
cairo_gl_context_t *ctx = NULL;
cairo_clip_t *clip = composite->clip;
cairo_bool_t is_pixel_aligned = FALSE;
- if (! can_use_msaa_compositor (dst, CAIRO_ANTIALIAS_DEFAULT))
+ if (! can_use_msaa_compositor (dst, CAIRO_ANTIALIAS_DEFAULT)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
if (composite->op == CAIRO_OPERATOR_CLEAR &&
- composite->original_mask_pattern != NULL)
+ composite->original_mask_pattern != NULL) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
/* GL compositing operators cannot properly represent a mask operation
using the SOURCE compositing operator in one pass. This only matters if
if (! _cairo_pattern_is_opaque (&composite->source_pattern.base,
&composite->source_sample_area)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_gl_msaa_compositor_mask_source_operator (compositor, composite);
}
if (_should_use_unbounded_surface (composite)) {
cairo_surface_t* surface = _prepare_unbounded_surface (dst);
- if (unlikely (surface == NULL))
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
/* This may be a paint operation. */
if (composite->original_mask_pattern == NULL) {
if (unlikely (status)) {
cairo_surface_destroy (surface);
+ CAIRO_TRACE_END (__func__);
return status;
}
+ CAIRO_TRACE_END (__func__);
return _paint_back_unbounded_surface (compositor, composite, surface);
}
if (! is_pixel_aligned) {
status = _blit_texture_to_renderbuffer (dst);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
}
status = _cairo_gl_composite_init (&setup,
op,
dst,
FALSE /* assume_component_alpha */);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_gl_composite_set_source (&setup,
composite->original_source_pattern,
if (clip) {
cairo_clip_t *clip_copy = _cairo_clip_copy (clip);
-
+
clip_copy = _cairo_clip_intersect_rectangle (clip_copy, &rect);
status = _cairo_gl_msaa_compositor_draw_clip (ctx, &setup,
clip_copy);
if (ctx)
status = _cairo_gl_context_release (ctx, status);
+ CAIRO_TRACE_END (__func__);
return status;
}
double tolerance,
cairo_antialias_t antialias)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *) composite->surface;
struct _tristrip_composite_info info;
cairo_bool_t use_color_attribute;
cairo_rectangle_int_t stroke_extents;
- if (! can_use_msaa_compositor (dst, antialias))
+ if (! can_use_msaa_compositor (dst, antialias)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
if (! _cairo_path_fixed_stroke_is_rectilinear (path)) {
_cairo_path_fixed_approximate_fill_extents (path, &stroke_extents);
if (stroke_extents.width != 0 &&
stroke_extents.height != 0) {
- if ((stroke_extents.width / stroke_extents.height > 10 &&
+ if ((stroke_extents.width / stroke_extents.height > 10 &&
stroke_extents.height < 10) ||
- (stroke_extents.height / stroke_extents.width > 10 &&
+ (stroke_extents.height / stroke_extents.width > 10 &&
stroke_extents.width < 10)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
}
}
if (composite->is_bounded == FALSE) {
cairo_surface_t* surface = _prepare_unbounded_surface (dst);
- if (unlikely (surface == NULL))
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
status = _cairo_compositor_stroke (compositor, surface,
CAIRO_OPERATOR_SOURCE,
tolerance, antialias, NULL);
if (unlikely (status)) {
cairo_surface_destroy (surface);
+ CAIRO_TRACE_END (__func__);
return status;
}
+ CAIRO_TRACE_END (__func__);
return _paint_back_unbounded_surface (compositor, composite, surface);
}
if (antialias != CAIRO_ANTIALIAS_NONE) {
status = _blit_texture_to_renderbuffer (dst);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
}
status = _cairo_gl_composite_init (&info.setup,
composite->op,
dst,
FALSE /* assume_component_alpha */);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
info.ctx = NULL;
use_color_attribute = _cairo_gl_hairline_style_is_hairline (style, ctm);
if (info.ctx)
status = _cairo_gl_context_release (info.ctx, status);
+ CAIRO_TRACE_END (__func__);
return status;
}
double tolerance,
cairo_antialias_t antialias)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_composite_t setup;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *) composite->surface;
cairo_gl_context_t *ctx = NULL;
cairo_rectangle_int_t fill_extents;
struct _tristrip_composite_info info;
- if (! can_use_msaa_compositor (dst, antialias))
+ if (! can_use_msaa_compositor (dst, antialias)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
if (! _cairo_path_fixed_fill_is_rectilinear (path)) {
_cairo_path_fixed_approximate_fill_extents (path, &fill_extents);
if (fill_extents.width != 0 && fill_extents.height != 0) {
- if ((fill_extents.width / fill_extents.height > 10 &&
+ if ((fill_extents.width / fill_extents.height > 10 &&
fill_extents.height < 10) ||
- (fill_extents.height / fill_extents.width > 10 &&
+ (fill_extents.height / fill_extents.width > 10 &&
fill_extents.width < 10)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
}
}
if (composite->is_bounded == FALSE) {
cairo_surface_t* surface = _prepare_unbounded_surface (dst);
- if (unlikely (surface == NULL))
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
status = _cairo_compositor_fill (compositor, surface,
if (unlikely (status)) {
cairo_surface_destroy (surface);
+ CAIRO_TRACE_END (__func__);
return status;
}
+ CAIRO_TRACE_END (__func__);
return _paint_back_unbounded_surface (compositor, composite, surface);
}
if (antialias != CAIRO_ANTIALIAS_NONE) {
status = _blit_texture_to_renderbuffer (dst);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
}
draw_path_with_traps = ! _cairo_path_fixed_is_simple_quad (path);
_cairo_gl_msaa_compositor_set_clip (composite, &setup);
if (antialias != CAIRO_ANTIALIAS_NONE)
_cairo_gl_composite_set_multisample (&setup);
-
+
status = _cairo_gl_composite_begin (&setup, &ctx);
if (unlikely (status))
goto cleanup_setup;
if (draw_path_with_traps && !path->is_convex)
_cairo_traps_fini (&traps);
+ CAIRO_TRACE_END (__func__);
return status;
}
int num_glyphs,
cairo_bool_t overlap)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_surface_t *src = NULL;
int src_x, src_y;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *) composite->surface;
query_surface_capabilities (dst);
- if (! dst->supports_stencil)
+ if (! dst->supports_stencil) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
- if (composite->op == CAIRO_OPERATOR_CLEAR)
+ if (composite->op == CAIRO_OPERATOR_CLEAR) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
if (composite->is_bounded == FALSE) {
cairo_surface_t* surface = _prepare_unbounded_surface (dst);
- if (unlikely (surface == NULL))
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
status = _cairo_compositor_glyphs (compositor, surface,
CAIRO_OPERATOR_SOURCE,
if (unlikely (status)) {
cairo_surface_destroy (surface);
+ CAIRO_TRACE_END (__func__);
return status;
}
+ CAIRO_TRACE_END (__func__);
return _paint_back_unbounded_surface (compositor, composite, surface);
}
/*
finish:
if (src)
cairo_surface_destroy (src);
-
+ CAIRO_TRACE_END (__func__);
return status;
}
_cairo_gl_msaa_compositor_init (cairo_compositor_t *compositor,
const cairo_compositor_t *delegate)
{
+ CAIRO_TRACE_BEGIN (__func__);
compositor->delegate = delegate;
compositor->lazy_init = TRUE;
compositor->paint = _cairo_gl_msaa_compositor_paint;
compositor->fill = _cairo_gl_msaa_compositor_fill;
compositor->stroke = _cairo_gl_msaa_compositor_stroke;
compositor->glyphs = _cairo_gl_msaa_compositor_glyphs;
+ CAIRO_TRACE_END (__func__);
}
const cairo_compositor_t *
#include "cairo-surface-backend-private.h"
#include "cairo-surface-shadow-private.h"
#include "cairo-surface-scale-translate-private.h"
+#include "cairo-ttrace.h"
static const cairo_surface_backend_t _cairo_gl_surface_backend;
int width, int height,
int *width_out, int *height_out)
{
+ CAIRO_TRACE_BEGIN (__func__);
int shadow_width, shadow_height;
cairo_gl_surface_t *shadow_surface = NULL;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
- if (ctx == NULL)
+ if (ctx == NULL) {
+ CAIRO_TRACE_END (__func__);
return NULL;
+ }
shadow_surface = ctx->shadow_scratch_surfaces[0];
-
+
if (shadow_surface) {
shadow_width = shadow_surface->width;
shadow_height = shadow_surface->height;
shadow_height >= height) {
*width_out = width;
*height_out = height;
+ CAIRO_TRACE_END (__func__);
return cairo_surface_reference (&shadow_surface->base);
}
else {
shadow_height);
if (unlikely (shadow_surface->base.status)) {
cairo_surface_destroy (&shadow_surface->base);
+ CAIRO_TRACE_END (__func__);
return NULL;
}
*height_out *= 0.5;
}
+ CAIRO_TRACE_END (__func__);
return cairo_surface_reference (&shadow_surface->base);
}
int width, int height,
unsigned int index)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *mask_surface = NULL;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
- if (ctx == NULL)
+ if (ctx == NULL) {
+ CAIRO_TRACE_END (__func__);
return NULL;
+ }
- if (index > 1)
+ if (index > 1) {
+ CAIRO_TRACE_END (__func__);
return NULL;
+ }
mask_surface = ctx->shadow_masks[index];
height);
if (unlikely (mask_surface->base.status)) {
cairo_surface_destroy (&mask_surface->base);
+ CAIRO_TRACE_END (__func__);
return NULL;
}
_cairo_surface_release_device_reference (&mask_surface->base);
mask_surface->needs_to_cache = FALSE;
mask_surface->force_no_cache = TRUE;
-
+ CAIRO_TRACE_END (__func__);
return cairo_surface_reference (&mask_surface->base);
}
int width, int height,
cairo_bool_t for_source)
{
+ CAIRO_TRACE_BEGIN (__func__);
int shadow_width, shadow_height;
cairo_gl_surface_t *shadow_surface = NULL;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
- if (ctx == NULL)
+ if (ctx == NULL) {
+ CAIRO_TRACE_END (__func__);
return NULL;
+ }
if (! for_source)
shadow_surface = ctx->shadow_scratch_surfaces[1];
else
shadow_surface = ctx->shadow_scratch_surfaces[2];
-
+
if (shadow_surface) {
shadow_width = shadow_surface->width;
shadow_height = shadow_surface->height;
if (! shadow_surface) {
shadow_surface = (cairo_gl_surface_t *)
_cairo_gl_surface_create_scratch (ctx,
- CAIRO_CONTENT_COLOR_ALPHA,
+ CAIRO_CONTENT_COLOR_ALPHA,
width, height);
if (unlikely (shadow_surface->base.status)) {
cairo_surface_destroy (&shadow_surface->base);
+ CAIRO_TRACE_END (__func__);
return NULL;
}
_cairo_surface_release_device_reference (&shadow_surface->base);
shadow_surface->needs_to_cache = FALSE;
shadow_surface->force_no_cache = TRUE;
+ CAIRO_TRACE_END (__func__);
return cairo_surface_reference (&shadow_surface->base);
}
int width, int height,
unsigned index)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *mask_surface = NULL;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
- if (ctx == NULL)
+ if (ctx == NULL) {
+ CAIRO_TRACE_END (__func__);
return NULL;
+ }
- if (index > 1)
+ if (index > 1) {
+ CAIRO_TRACE_END (__func__);
return NULL;
+ }
mask_surface = ctx->shadow_masks[index + 2];
-
+
if (mask_surface) {
if (mask_surface->width != width ||
- mask_surface->height != height) {
+ mask_surface->height != height) {
cairo_surface_destroy (&mask_surface->base);
mask_surface = NULL;
ctx->shadow_masks[index + 2] = NULL;
height);
if (unlikely (mask_surface->base.status)) {
cairo_surface_destroy (&mask_surface->base);
+ CAIRO_TRACE_END (__func__);
return NULL;
}
_cairo_surface_release_device_reference (&mask_surface->base);
mask_surface->needs_to_cache = FALSE;
mask_surface->force_no_cache = TRUE;
+ CAIRO_TRACE_END (__func__);
return cairo_surface_reference (&mask_surface->base);
}
cairo_content_t content,
int width, int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
assert (width > 0 && height > 0);
_cairo_surface_init (&surface->base,
surface->content_cleared = FALSE;
_cairo_gl_surface_embedded_operand_init (surface);
+ CAIRO_TRACE_END (__func__);
}
static cairo_bool_t
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *surface;
surface = calloc (1, sizeof (cairo_gl_surface_t));
- if (unlikely (surface == NULL))
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ }
surface->tex = tex;
_cairo_gl_surface_init (&ctx->base, surface, content, width, height);
ctx->dispatch.TexParameteri (ctx->tex_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
ctx->dispatch.TexParameteri (ctx->tex_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ CAIRO_TRACE_END (__func__);
return &surface->base;
}
int height,
cairo_bool_t for_caching)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *surface;
GLenum format;
GLuint tex;
surface = (cairo_gl_surface_t *)
_cairo_gl_surface_create_scratch_for_texture (ctx, content,
tex, width, height);
- if (unlikely (surface->base.status))
+ if (unlikely (surface->base.status)) {
+ CAIRO_TRACE_END (__func__);
return &surface->base;
+ }
surface->owns_tex = TRUE;
width, height, 0,
format, GL_UNSIGNED_BYTE, NULL);
+ CAIRO_TRACE_END (__func__);
return &surface->base;
}
_cairo_gl_surface_clear (cairo_gl_surface_t *surface,
const cairo_color_t *color)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_context_t *ctx;
cairo_status_t status;
double r, g, b, a;
status = _cairo_gl_context_acquire (surface->base.device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (ctx->current_target == surface)
_cairo_gl_composite_flush (ctx);
surface->content_changed = TRUE;
surface->content_synced = FALSE;
surface->content_cleared = TRUE;
+ CAIRO_TRACE_END (__func__);
return _cairo_gl_context_release (ctx, status);
}
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *surface;
cairo_int_status_t status;
surface = (cairo_gl_surface_t *)
_cairo_gl_surface_create_scratch (ctx, content, width, height);
- if (unlikely (surface->base.status))
+ if (unlikely (surface->base.status)) {
+ CAIRO_TRACE_END (__func__);
return &surface->base;
+ }
/* Cairo surfaces start out initialized to transparent (black) */
status = _cairo_gl_surface_clear (surface, CAIRO_COLOR_TRANSPARENT);
if (unlikely (status)) {
cairo_surface_destroy (&surface->base);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
}
+ CAIRO_TRACE_END (__func__);
return &surface->base;
}
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_context_t *ctx;
cairo_gl_surface_t *surface;
cairo_status_t status;
- if (! CAIRO_CONTENT_VALID (content))
+ if (! CAIRO_CONTENT_VALID (content)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT));
+ }
- if (abstract_device == NULL)
+ if (abstract_device == NULL) {
+ CAIRO_TRACE_END (__func__);
return _cairo_image_surface_create_with_content (content, width, height);
+ }
- if (abstract_device->status)
+ if (abstract_device->status) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (abstract_device->status);
+ }
- if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_GL)
+ if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_GL) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
+ }
status = _cairo_gl_context_acquire (abstract_device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
+ }
if (! _cairo_gl_surface_size_valid_for_context (ctx, width, height)) {
status = _cairo_gl_context_release (ctx, status);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
}
if (unlikely (surface->base.status)) {
status = _cairo_gl_context_release (ctx, surface->base.status);
cairo_surface_destroy (&surface->base);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
}
status = _cairo_gl_context_release (ctx, status);
if (unlikely (status)) {
cairo_surface_destroy (&surface->base);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
}
+ CAIRO_TRACE_END (__func__);
return &surface->base;
}
slim_hidden_def (cairo_gl_surface_create);
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_context_t *ctx;
cairo_gl_surface_t *surface;
cairo_status_t status;
- if (! CAIRO_CONTENT_VALID (content))
+ if (! CAIRO_CONTENT_VALID (content)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT));
+ }
- if (abstract_device == NULL)
+ if (abstract_device == NULL) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NULL_POINTER));
+ }
- if (abstract_device->status)
+ if (abstract_device->status) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (abstract_device->status);
+ }
- if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_GL)
+ if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_GL) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_DEVICE_TYPE_MISMATCH));
+ }
status = _cairo_gl_context_acquire (abstract_device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
+ }
if (! _cairo_gl_surface_size_valid_for_context (ctx, width, height)) {
status = _cairo_gl_context_release (ctx, status);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
}
_cairo_gl_surface_create_scratch_for_texture (ctx, content,
tex, width, height);
status = _cairo_gl_context_release (ctx, status);
-
+ CAIRO_TRACE_END (__func__);
return &surface->base;
}
slim_hidden_def (cairo_gl_surface_create_for_texture);
{
cairo_gl_surface_t *surface = (cairo_gl_surface_t *) abstract_surface;
- if (unlikely (abstract_surface->status))
+ if (unlikely (abstract_surface->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (unlikely (abstract_surface->finished)) {
_cairo_surface_set_error (abstract_surface,
_cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ CAIRO_TRACE_END (__func__);
return;
}
if (! _cairo_surface_is_gl (abstract_surface)) {
_cairo_surface_set_error (abstract_surface,
CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+
+ CAIRO_TRACE_END (__func__);
return;
}
cairo_status_t status;
status = _cairo_gl_context_acquire (surface->base.device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
+
/* And in any case we should flush any pending operations. */
_cairo_gl_composite_flush (ctx);
if (status)
status = _cairo_surface_set_error (abstract_surface, status);
}
+ CAIRO_TRACE_END (__func__);
}
static cairo_surface_t *
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *surface = abstract_surface;
cairo_gl_context_t *ctx;
cairo_status_t status;
- if (! _cairo_gl_surface_size_valid (abstract_surface, width, height))
+ if (! _cairo_gl_surface_size_valid (abstract_surface, width, height)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_image_surface_create_with_content (content, width, height);
+ }
status = _cairo_gl_context_acquire (surface->device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
+ }
surface = _cairo_gl_surface_create_and_clear_scratch (ctx, content, width, height);
status = _cairo_gl_context_release (ctx, status);
if (unlikely (status)) {
cairo_surface_destroy (surface);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
}
+ CAIRO_TRACE_END (__func__);
return surface;
}
int x, int y,
int width, int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_composite_t setup;
cairo_status_t status;
_cairo_gl_composite_flush (ctx);
ctx->dispatch.ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ CAIRO_TRACE_END (__func__);
return status;
}
int dst_x, int dst_y,
cairo_bool_t force_flush)
{
+ CAIRO_TRACE_BEGIN (__func__);
GLenum internal_format, format, type;
cairo_bool_t has_alpha, needs_swap;
cairo_image_surface_t *clone = NULL;
cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;
status = _cairo_gl_context_acquire (dst->base.device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (_cairo_gl_get_flavor (&ctx->dispatch) == CAIRO_GL_FLAVOR_ES2 ||
_cairo_gl_get_flavor (&ctx->dispatch) == CAIRO_GL_FLAVOR_ES3) {
dst->content_synced = FALSE;
}
+ CAIRO_TRACE_END (__func__);
return status;
}
static cairo_status_t
_cairo_gl_surface_finish (void *abstract_surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *surface = abstract_surface;
cairo_status_t status;
cairo_gl_context_t *ctx;
status = _cairo_gl_context_acquire (surface->base.device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if ((ctx->operands[CAIRO_GL_TEX_SOURCE].type == CAIRO_GL_OPERAND_TEXTURE ||
ctx->operands[CAIRO_GL_TEX_SOURCE].type == CAIRO_GL_OPERAND_GAUSSIAN) &&
if (surface->clip_on_stencil_buffer)
_cairo_clip_destroy (surface->clip_on_stencil_buffer);
+ CAIRO_TRACE_END (__func__);
return _cairo_gl_context_release (ctx, status);
}
_cairo_gl_surface_map_to_image (void *abstract_surface,
const cairo_rectangle_int_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *surface = abstract_surface;
cairo_image_surface_t *image;
cairo_gl_context_t *ctx;
status = _cairo_gl_context_acquire (surface->base.device, &ctx);
if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_image_surface_create_in_error (status);
}
cpp = 1;
} else {
ASSERT_NOT_REACHED;
+ CAIRO_TRACE_END (__func__);
return NULL;
}
-1);
if (unlikely (image->base.status)) {
status = _cairo_gl_context_release (ctx, status);
+ CAIRO_TRACE_END (__func__);
return image;
}
* is clear, we can avoid downloading data. */
if (surface->base.is_clear || surface->base.serial == 0) {
status = _cairo_gl_context_release (ctx, status);
+ CAIRO_TRACE_END (__func__);
return image;
}
status = _cairo_gl_context_release (ctx, status);
if (unlikely (status)) {
cairo_surface_destroy (&image->base);
+ CAIRO_TRACE_END (__func__);
return _cairo_image_surface_create_in_error (status);
}
row = malloc (image->stride);
if (unlikely (row == NULL)) {
cairo_surface_destroy (&image->base);
+ CAIRO_TRACE_END (__func__);
return _cairo_image_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
}
}
image->base.is_clear = FALSE;
+ CAIRO_TRACE_END (__func__);
return image;
}
_cairo_gl_surface_unmap_image (void *abstract_surface,
cairo_image_surface_t *image)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
status = _cairo_gl_surface_draw_image (abstract_surface, image,
cairo_surface_finish (&image->base);
cairo_surface_destroy (&image->base);
+ CAIRO_TRACE_END (__func__);
return status;
}
static cairo_status_t
_cairo_gl_surface_flush (void *abstract_surface, unsigned flags)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_gl_surface_t *surface = abstract_surface;
cairo_status_t status;
cairo_gl_context_t *ctx;
- if (flags)
+ if (flags) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _cairo_gl_context_acquire (surface->base.device, &ctx);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (((ctx->operands[CAIRO_GL_TEX_SOURCE].type == CAIRO_GL_OPERAND_TEXTURE ||
ctx->operands[CAIRO_GL_TEX_SOURCE].type == CAIRO_GL_OPERAND_GAUSSIAN) &&
ctx->dispatch.Flush ();
#endif
+ CAIRO_TRACE_END (__func__);
return _cairo_gl_context_release (ctx, status);
}
const cairo_pattern_t *source,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
status = cairo_device_acquire (dst->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_surface_shadow_paint (surface, op, source, clip,
&source->shadow);
ctx->source_scratch_in_use = FALSE;
if (unlikely (status)) {
- cairo_device_release (dst->base.device);
+ cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
dst->content_changed = TRUE;
dst->content_synced = FALSE;
}
-
+
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (op == CAIRO_OPERATOR_CLEAR) {
status = _cairo_gl_surface_clear (surface, CAIRO_COLOR_TRANSPARENT);
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
else if (source->type == CAIRO_PATTERN_TYPE_SOLID &&
(op == CAIRO_OPERATOR_OVER && _cairo_pattern_is_opaque_solid (source)))) {
status = _cairo_gl_surface_clear (surface,
&((cairo_solid_pattern_t *) source)->color);
- cairo_device_release (dst->base.device);
+ cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
}
dst->content_changed = TRUE;
dst->content_synced = FALSE;
}
-
+
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
const cairo_pattern_t *mask,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *) surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
status = cairo_device_acquire (dst->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_surface_shadow_mask (surface, op, source, mask, clip,
&source->shadow);
ctx->source_scratch_in_use = FALSE;
if (unlikely (status)) {
- cairo_device_release (dst->base.device);
+ cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (status == CAIRO_INT_STATUS_SUCCESS) {
dst->content_changed = TRUE;
dst->content_synced = FALSE;
- }
-
+ }
+
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (status == CAIRO_INT_STATUS_SUCCESS) {
dst->content_changed = TRUE;
dst->content_synced = FALSE;
-
+
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
cairo_shadow_type_t shadow_type = source->shadow.type;
status = cairo_device_acquire (dst->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (shadow_type != CAIRO_SHADOW_INSET)
status = _cairo_surface_shadow_stroke (surface, op, source, path,
ctx->source_scratch_in_use = FALSE;
if (unlikely (status)) {
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
source->shadow.draw_shadow_only) {
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (unlikely (status)) {
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
cairo_shadow_type_t shadow_type = source->shadow.type;
status = cairo_device_acquire (dst->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (shadow_type != CAIRO_SHADOW_INSET)
status = _cairo_surface_shadow_fill (surface, op, source, path,
ctx->source_scratch_in_use = FALSE;
if (unlikely (status)) {
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
source->shadow.draw_shadow_only) {
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (unlikely (status)) {
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_scaled_font_t *font,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_gl_surface_t *dst = (cairo_gl_surface_t *)surface;
cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
cairo_shadow_type_t shadow_type = source->shadow.type;
status = cairo_device_acquire (dst->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (shadow_type != CAIRO_SHADOW_INSET)
status = _cairo_surface_shadow_glyphs (surface, op, source,
ctx->source_scratch_in_use = FALSE;
if (unlikely (status)) {
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
source->shadow.draw_shadow_only) {
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (unlikely (status)) {
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
ctx->source_scratch_in_use = FALSE;
cairo_device_release (dst->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
#include "cairo-gstate-private.h"
#include "cairo-pattern-private.h"
#include "cairo-traps-private.h"
+#include "cairo-ttrace.h"
#if _XOPEN_SOURCE >= 600 || defined (_ISOC99_SOURCE)
#define ISFINITE(x) isfinite (x)
_cairo_gstate_init (cairo_gstate_t *gstate,
cairo_surface_t *target)
{
+ CAIRO_TRACE_BEGIN (__func__);
VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));
gstate->next = NULL;
/* Now that the gstate is fully initialized and ready for the eventual
* _cairo_gstate_fini(), we can check for errors (and not worry about
* the resource deallocation). */
+ CAIRO_TRACE_END (__func__);
return target->status;
}
void
_cairo_gstate_fini (cairo_gstate_t *gstate)
{
+ CAIRO_TRACE_BEGIN (__func__);
_cairo_stroke_style_fini (&gstate->stroke_style);
cairo_font_face_destroy (gstate->font_face);
memset (&gstate->shadow, 0, sizeof (cairo_shadow_t));
+ CAIRO_TRACE_END (__func__);
VG (VALGRIND_MAKE_MEM_NOACCESS (gstate, sizeof (cairo_gstate_t)));
}
_cairo_gstate_set_source (cairo_gstate_t *gstate,
cairo_pattern_t *source)
{
- if (source->status)
+ CAIRO_TRACE_BEGIN (__func__);
+ if (source->status) {
+ CAIRO_TRACE_END (__func__);
return source->status;
+ }
source = cairo_pattern_reference (source);
cairo_pattern_destroy (gstate->source);
gstate->source = source;
gstate->source_ctm_inverse = gstate->ctm_inverse;
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
cairo_status_t
_cairo_gstate_paint (cairo_gstate_t *gstate)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_pattern_union_t source_pattern;
const cairo_pattern_t *pattern;
cairo_status_t status;
cairo_bool_t destroy_pattern = FALSE;
status = _cairo_gstate_get_pattern_status (gstate->source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
- if (gstate->op == CAIRO_OPERATOR_DEST)
+ if (gstate->op == CAIRO_OPERATOR_DEST) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
- if (_cairo_clip_is_all_clipped (gstate->clip))
+ if (_cairo_clip_is_all_clipped (gstate->clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
if (gstate->source->filter == CAIRO_FILTER_GAUSSIAN)
status = _cairo_pattern_create_gaussian_matrix (gstate->source, 1024);
op = _reduce_op (gstate);
/* do not use static pattern */
if (op == CAIRO_OPERATOR_CLEAR) {
- if (! _cairo_gstate_has_shadow (gstate))
+ if (! _cairo_gstate_has_shadow (gstate))
pattern = &_cairo_pattern_clear.base;
else {
pattern = cairo_pattern_create_rgba (0, 0, 0, 0);
gstate->clip);
if (destroy_pattern)
cairo_pattern_destroy ((cairo_pattern_t *)pattern);
-
+ CAIRO_TRACE_END (__func__);
return status;
}
_cairo_gstate_mask (cairo_gstate_t *gstate,
cairo_pattern_t *mask)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_pattern_union_t source_pattern, mask_pattern;
const cairo_pattern_t *source;
cairo_operator_t op;
cairo_bool_t destroy_pattern = FALSE;
status = _cairo_gstate_get_pattern_status (mask);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_gstate_get_pattern_status (gstate->source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (gstate->source->filter == CAIRO_FILTER_GAUSSIAN)
status = _cairo_pattern_create_gaussian_matrix (gstate->source, 1024);
if (mask->filter == CAIRO_FILTER_GAUSSIAN)
status = _cairo_pattern_create_gaussian_matrix (mask, 1024);
- if (gstate->op == CAIRO_OPERATOR_DEST)
+ if (gstate->op == CAIRO_OPERATOR_DEST) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
- if (_cairo_clip_is_all_clipped (gstate->clip))
+ if (_cairo_clip_is_all_clipped (gstate->clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
assert (gstate->opacity == 1.0);
- if (_cairo_pattern_is_opaque (mask, NULL))
+ if (_cairo_pattern_is_opaque (mask, NULL)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_gstate_paint (gstate);
+ }
if (_cairo_pattern_is_clear (mask) &&
_cairo_operator_bounded_by_mask (gstate->op))
{
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
if (destroy_pattern)
cairo_pattern_destroy ((cairo_pattern_t *)source);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_status_t
_cairo_gstate_stroke (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_pattern_union_t source_pattern;
cairo_stroke_style_t style;
double dash[2];
cairo_matrix_t aggregate_transform_inverse;
status = _cairo_gstate_get_pattern_status (gstate->source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (gstate->source->filter == CAIRO_FILTER_GAUSSIAN)
status = _cairo_pattern_create_gaussian_matrix (gstate->source,
gstate->stroke_style.line_width);
- if (gstate->op == CAIRO_OPERATOR_DEST)
+ if (gstate->op == CAIRO_OPERATOR_DEST) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
- if (gstate->stroke_style.line_width <= 0.0)
+ if (gstate->stroke_style.line_width <= 0.0) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
- if (_cairo_clip_is_all_clipped (gstate->clip))
+ if (_cairo_clip_is_all_clipped (gstate->clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
assert (gstate->opacity == 1.0);
if (_cairo_gstate_has_shadow (gstate))
source_pattern.base.shadow = gstate->shadow;
- return _cairo_surface_stroke (gstate->target,
+ status = _cairo_surface_stroke (gstate->target,
gstate->op,
&source_pattern.base,
path,
gstate->tolerance,
gstate->antialias,
gstate->clip);
+ CAIRO_TRACE_END (__func__);
+ return status;
}
cairo_status_t
double y,
cairo_bool_t *inside_ret)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
cairo_rectangle_int_t extents;
cairo_box_t limit;
if (gstate->stroke_style.line_width <= 0.0) {
*inside_ret = FALSE;
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
y < extents.y || y > extents.y + extents.height)
{
*inside_ret = FALSE;
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
BAIL:
_cairo_traps_fini (&traps);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_status_t
_cairo_gstate_fill (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
const cairo_pattern_t *pattern;
cairo_bool_t destroy_pattern = FALSE;
status = _cairo_gstate_get_pattern_status (gstate->source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (gstate->source->filter == CAIRO_FILTER_GAUSSIAN)
status = _cairo_pattern_create_gaussian_matrix (gstate->source, 1024);
- if (gstate->op == CAIRO_OPERATOR_DEST)
+ if (gstate->op == CAIRO_OPERATOR_DEST) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
- if (_cairo_clip_is_all_clipped (gstate->clip))
+ if (_cairo_clip_is_all_clipped (gstate->clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
assert (gstate->opacity == 1.0);
if (_cairo_path_fixed_fill_is_empty (path)) {
- if (_cairo_operator_bounded_by_mask (gstate->op))
+ if (_cairo_operator_bounded_by_mask (gstate->op)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
pattern = &_cairo_pattern_clear.base;
status = _cairo_surface_paint (gstate->target,
op = _reduce_op (gstate);
/* FIXME: I don't like this */
if (op == CAIRO_OPERATOR_CLEAR) {
- if (_cairo_gstate_has_shadow (gstate))
+ if (_cairo_gstate_has_shadow (gstate))
pattern = &_cairo_pattern_clear.base;
else {
pattern = cairo_pattern_create_rgba (0, 0, 0, 0);
if (destroy_pattern)
cairo_pattern_destroy ((cairo_pattern_t *)pattern);
+ CAIRO_TRACE_END (__func__);
return status;
}
#include "cairo-surface-subsurface-private.h"
#include "cairo-surface-shadow-private.h"
#include "cairo-list-inline.h"
+#include "cairo-ttrace.h"
/* Limit on the width / height of an image surface in pixels. This is
* mainly determined by coordinates of things sent to pixman at the
cairo_surface_destroy (shadow->surface);
free (shadow);
}
- shadow_caches_size = 0;
+ shadow_caches_size = 0;
}
}
pixman_image_t *pixman_image,
pixman_format_code_t pixman_format)
{
+ CAIRO_TRACE_BEGIN (__func__);
surface->parent = NULL;
surface->pixman_image = pixman_image;
surface->compositor = _cairo_image_spans_compositor_get ();
_cairo_image_shadow_caches_init ();
+ CAIRO_TRACE_END (__func__);
}
cairo_surface_t *
_cairo_image_surface_create_for_pixman_image (pixman_image_t *pixman_image,
pixman_format_code_t pixman_format)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *surface;
surface = malloc (sizeof (cairo_image_surface_t));
- if (unlikely (surface == NULL))
+ if (unlikely (surface == NULL)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ }
_cairo_surface_init (&surface->base,
&_cairo_image_surface_backend,
_cairo_image_surface_init (surface, pixman_image, pixman_format);
+ CAIRO_TRACE_END (__func__);
return &surface->base;
}
int height,
int stride)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *surface;
pixman_image_t *pixman_image;
if (! _cairo_image_surface_is_size_valid (width, height))
{
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
}
pixman_image = pixman_image_create_bits (pixman_format, width, height,
(uint32_t *) data, stride);
- if (unlikely (pixman_image == NULL))
+ if (unlikely (pixman_image == NULL)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ }
surface = _cairo_image_surface_create_for_pixman_image (pixman_image,
pixman_format);
if (unlikely (surface->status)) {
pixman_image_unref (pixman_image);
+ CAIRO_TRACE_END (__func__);
return surface;
}
/* we can not make any assumptions about the initial state of user data */
surface->is_clear = data == NULL;
+ CAIRO_TRACE_END (__func__);
return surface;
}
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
pixman_format_code_t pixman_format;
+ cairo_surface_t *image_surface = NULL;
- if (! CAIRO_FORMAT_VALID (format))
+ if (! CAIRO_FORMAT_VALID (format)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
+ }
pixman_format = _cairo_format_to_pixman_format_code (format);
- return _cairo_image_surface_create_with_pixman_format (NULL, pixman_format,
+ image_surface = _cairo_image_surface_create_with_pixman_format (NULL, pixman_format,
width, height, -1);
+ CAIRO_TRACE_END (__func__);
+ return image_surface;
}
slim_hidden_def (cairo_image_surface_create);
cairo_surface_t *
_cairo_image_surface_snapshot (void *abstract_surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *image = abstract_surface;
cairo_image_surface_t *clone;
clone = (cairo_image_surface_t *)
_cairo_image_surface_create_for_pixman_image (image->pixman_image,
image->pixman_format);
- if (unlikely (clone->base.status))
+ if (unlikely (clone->base.status)) {
+ CAIRO_TRACE_END (__func__);
return &clone->base;
+ }
image->pixman_image = NULL;
image->owns_data = FALSE;
clone->color = image->color;
clone->owns_data = TRUE;
+ CAIRO_TRACE_END (__func__);
return &clone->base;
}
image->width,
image->height,
0);
- if (unlikely (clone->base.status))
+ if (unlikely (clone->base.status)) {
+ CAIRO_TRACE_END (__func__);
return &clone->base;
+ }
if (clone->stride == image->stride) {
memcpy (clone->data, image->data, clone->stride * clone->height);
image->width, image->height);
}
clone->base.is_clear = FALSE;
+ CAIRO_TRACE_END (__func__);
return &clone->base;
}
_cairo_image_surface_map_to_image (void *abstract_other,
const cairo_rectangle_int_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *other = abstract_other;
cairo_surface_t *surface;
uint8_t *data;
other->stride);
cairo_surface_set_device_offset (surface, -extents->x, -extents->y);
+ CAIRO_TRACE_END (__func__);
return (cairo_image_surface_t *) surface;
}
cairo_status_t
_cairo_image_surface_finish (void *abstract_surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *surface = abstract_surface;
if (surface->pixman_image) {
_cairo_image_shadow_caches_destroy ();
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
const cairo_pattern_t *source,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *surface = abstract_surface;
- cairo_int_status_t status;
+ cairo_int_status_t status;
TRACE ((stderr, "%s (surface=%d)\n",
__FUNCTION__, surface->base.unique_id));
status = cairo_device_acquire (surface->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_surface_shadow_paint (abstract_surface, op, source,
clip, &source->shadow);
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (source->shadow.draw_shadow_only) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
status = _cairo_compositor_paint (surface->compositor,
&surface->base, op, source, clip);
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
const cairo_pattern_t *mask,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *surface = abstract_surface;
cairo_int_status_t status;
__FUNCTION__, surface->base.unique_id));
status = cairo_device_acquire (surface->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_surface_shadow_mask (abstract_surface, op, source,
mask, clip, &source->shadow);
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (source->shadow.draw_shadow_only) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
status = _cairo_compositor_mask (surface->compositor,
&surface->base, op, source, mask, clip);
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_image_surface_t *surface = abstract_surface;
cairo_shadow_type_t shadow_type = source->shadow.type;
__FUNCTION__, surface->base.unique_id));
status = cairo_device_acquire (surface->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (shadow_type != CAIRO_SHADOW_INSET)
status = _cairo_surface_shadow_stroke (abstract_surface, op, source,
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (shadow_type == CAIRO_SHADOW_DROP &&
source->shadow.draw_shadow_only) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
&source->shadow);
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_image_surface_t *surface = abstract_surface;
cairo_shadow_type_t shadow_type = source->shadow.type;
__FUNCTION__, surface->base.unique_id));
status = cairo_device_acquire (surface->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (shadow_type != CAIRO_SHADOW_INSET)
status = _cairo_surface_shadow_fill (abstract_surface, op, source,
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (shadow_type == CAIRO_SHADOW_DROP &&
source->shadow.draw_shadow_only) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
&source->shadow);
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_scaled_font_t *scaled_font,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
cairo_image_surface_t *surface = abstract_surface;
cairo_shadow_type_t shadow_type = source->shadow.type;
__FUNCTION__, surface->base.unique_id));
status = cairo_device_acquire (surface->base.device);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (shadow_type != CAIRO_SHADOW_INSET)
status = _cairo_surface_shadow_glyphs (abstract_surface, op, source,
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (shadow_type == CAIRO_SHADOW_DROP &&
source->shadow.draw_shadow_only) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
if (unlikely (status)) {
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
&source->shadow);
cairo_device_release (surface->base.device);
+ CAIRO_TRACE_END (__func__);
return status;
}
int width, int height,
int *width_out, int *height_out)
{
+ CAIRO_TRACE_BEGIN (__func__);
int shadow_width, shadow_height;
cairo_image_surface_t *shadow_surface = NULL;
else
shadow_width = width;
}
-
+
if (height < MIN_IMAGE_SHADOW_SIZE)
shadow_height = height;
else if (has_blur) {
shadow_height);
if (unlikely (shadow_surface->base.status)) {
cairo_surface_destroy (&shadow_surface->base);
+ CAIRO_TRACE_END (__func__);
return NULL;
}
*width_out = shadow_width;
*height_out = shadow_height;
+ CAIRO_TRACE_END (__func__);
return &shadow_surface->base;
}
int x, int y,
int width, int height, int stride)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *surface = NULL;
cairo_status_t status;
pixman_image_t *image;
surface->base.is_clear = FALSE;
surface->owns_data = mem != NULL;
+ CAIRO_TRACE_END (__func__);
return surface;
cleanup_image:
free (mem);
cleanup:
cairo_surface_destroy (&surface->base);
+ CAIRO_TRACE_END (__func__);
return (cairo_image_surface_t *) _cairo_surface_create_in_error (status);
}
_cairo_image_surface_clone_subimage (cairo_surface_t *surface,
const cairo_rectangle_int_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *image;
cairo_surface_pattern_t pattern;
cairo_status_t status;
_cairo_format_from_content (surface->content),
extents->width,
extents->height);
- if (image->status)
+ if (image->status) {
+ CAIRO_TRACE_END (__func__);
return to_image_surface (image);
+ }
/* TODO: check me with non-identity device_transform. Should we
* clone the scaling, too? */
_cairo_image_surface_set_parent (to_image_surface (image),
cairo_surface_reference (surface));
+ CAIRO_TRACE_END (__func__);
return to_image_surface (image);
error:
cairo_surface_destroy (image);
+ CAIRO_TRACE_END (__func__);
return to_image_surface (_cairo_surface_create_in_error (status));
}
#include "cairo-error-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-output-stream-private.h"
+#include "cairo-ttrace.h"
#include <stdio.h>
#include <errno.h>
png_rw_ptr write_func,
void *closure)
{
+ CAIRO_TRACE_BEGIN (__func__);
int i;
cairo_int_status_t status;
cairo_image_surface_t *image;
&image,
&image_extra);
- if (status == CAIRO_INT_STATUS_UNSUPPORTED)
+ if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
+ CAIRO_TRACE_END (__func__);
return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
- else if (unlikely (status))
- return status;
+ }
+ else if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
+ return status;
+ }
/* PNG complains about "Image width or height is zero in IHDR" */
if (image->width == 0 || image->height == 0) {
BAIL1:
_cairo_surface_release_source_image (surface, image, image_extra);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_write_func_t write_func,
void *closure)
{
+ CAIRO_TRACE_BEGIN (__func__);
struct png_write_closure_t png_closure;
- if (surface->status)
+ if (surface->status) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
+ }
- if (surface->finished)
+ if (surface->finished) {
+ CAIRO_TRACE_END (__func__);
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
+ }
png_closure.write_func = write_func;
png_closure.closure = closure;
+ CAIRO_TRACE_END (__func__);
return write_png (surface, stream_write_func, &png_closure);
}
slim_hidden_def (cairo_surface_write_to_png_stream);
#include "cairo-error-private.h"
#include "cairo-region-private.h"
+#include "cairo-ttrace.h"
/* XXX need to update pixman headers to be const as appropriate */
#define CONST_CAST (pixman_region32_t *)
cairo_region_t *
cairo_region_create (void)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_region_t *region;
region = _cairo_malloc (sizeof (cairo_region_t));
- if (region == NULL)
+ if (region == NULL) {
+ CAIRO_TRACE_END (__func__);
return (cairo_region_t *) &_cairo_region_nil;
+ }
region->status = CAIRO_STATUS_SUCCESS;
CAIRO_REFERENCE_COUNT_INIT (®ion->ref_count, 1);
pixman_region32_init (®ion->rgn);
+ CAIRO_TRACE_END (__func__);
return region;
}
void
cairo_region_destroy (cairo_region_t *region)
{
- if (region == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (®ion->ref_count))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (region == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (®ion->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (®ion->ref_count));
- if (! _cairo_reference_count_dec_and_test (®ion->ref_count))
+ if (! _cairo_reference_count_dec_and_test (®ion->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
_cairo_region_fini (region);
free (region);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_region_destroy);
cairo_region_union_rectangle (cairo_region_t *dst,
const cairo_rectangle_int_t *rectangle)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status = CAIRO_STATUS_SUCCESS;
pixman_region32_t region;
- if (dst->status)
+ if (dst->status) {
+ CAIRO_TRACE_END (__func__);
return dst->status;
+ }
pixman_region32_init_rect (®ion,
rectangle->x, rectangle->y,
status = _cairo_region_set_error (dst, CAIRO_STATUS_NO_MEMORY);
pixman_region32_fini (®ion);
+ CAIRO_TRACE_END (__func__);
return status;
}
#include "cairo-region-private.h"
#include "cairo-surface-inline.h"
#include "cairo-tee-surface-private.h"
+#include "cairo-ttrace.h"
/**
* SECTION:cairo-surface
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *surface;
cairo_status_t status;
cairo_solid_pattern_t pattern;
- if (unlikely (other->status))
+ if (unlikely (other->status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (other->status);
- if (unlikely (other->finished))
+ }
+ if (unlikely (other->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
- if (unlikely (width < 0 || height < 0))
+ }
+ if (unlikely (width < 0 || height < 0)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+ }
- if (unlikely (! CAIRO_CONTENT_VALID (content)))
+ if (unlikely (! CAIRO_CONTENT_VALID (content))) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_CONTENT);
-
- if (unlikely (other->status))
+ }
+ if (unlikely (other->status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (other->status);
+ }
/* We inherit the device scale, so create a larger surface */
width = width * other->device_transform.xx;
_cairo_format_from_content (content),
width, height);
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface;
+ }
_cairo_surface_copy_similar_properties (surface, other);
cairo_surface_set_device_scale (surface,
other->device_transform.xx,
other->device_transform.yy);
- if (unlikely (surface->status))
+ if (unlikely (surface->status)){
+ CAIRO_TRACE_END (__func__);
return surface;
+ }
_cairo_pattern_init_solid (&pattern, CAIRO_COLOR_TRANSPARENT);
status = _cairo_surface_paint (surface,
assert (surface->is_clear);
+ CAIRO_TRACE_END (__func__);
return surface;
}
int width,
int height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *image;
- if (unlikely (other->status))
+ if (unlikely (other->status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (other->status);
- if (unlikely (other->finished))
+ }
+ if (unlikely (other->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
+ }
- if (unlikely (width < 0 || height < 0))
+ if (unlikely (width < 0 || height < 0)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
- if (unlikely (! CAIRO_FORMAT_VALID (format)))
+ }
+ if (unlikely (! CAIRO_FORMAT_VALID (format))) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_FORMAT);
+ }
image = NULL;
if (other->backend->create_similar_image)
assert (image->is_clear);
+ CAIRO_TRACE_END (__func__);
return image;
}
slim_hidden_def (cairo_surface_create_similar_image);
_cairo_surface_map_to_image (cairo_surface_t *surface,
const cairo_rectangle_int_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_image_surface_t *image = NULL;
assert (extents != NULL);
if (image == NULL)
image = _cairo_image_surface_clone_subimage (surface, extents);
+ CAIRO_TRACE_END (__func__);
return image;
}
_cairo_surface_unmap_image (cairo_surface_t *surface,
cairo_image_surface_t *image)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_pattern_t pattern;
cairo_rectangle_int_t extents;
cairo_clip_t *clip;
! _cairo_image_surface_is_clone (image))
{
status = surface->backend->unmap_image (surface, image);
- if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+ if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
}
_cairo_pattern_init_for_surface (&pattern, &image->base);
cairo_surface_finish (&image->base);
cairo_surface_destroy (&image->base);
+ CAIRO_TRACE_END (__func__);
return status;
}
cairo_surface_map_to_image (cairo_surface_t *surface,
const cairo_rectangle_int_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_rectangle_int_t rect;
cairo_image_surface_t *image;
cairo_status_t status;
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (surface->status);
- if (unlikely (surface->finished))
+ }
+ if (unlikely (surface->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
+ }
if (extents == NULL) {
- if (unlikely (! surface->backend->get_extents (surface, &rect)))
+ if (unlikely (! surface->backend->get_extents (surface, &rect))) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
-
+ }
extents = ▭
} else {
cairo_rectangle_int_t surface_extents;
/* If this surface is bounded, we can't map parts
* that are outside of it. */
if (likely (surface->backend->get_extents (surface, &surface_extents))) {
- if (unlikely (! _cairo_rectangle_contains_rectangle (&surface_extents, extents)))
+ if (unlikely (! _cairo_rectangle_contains_rectangle (&surface_extents, extents))) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+ }
}
}
status = image->base.status;
if (unlikely (status)) {
cairo_surface_destroy (&image->base);
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (status);
}
image = _cairo_image_surface_clone_subimage (surface, extents);
}
+ CAIRO_TRACE_END (__func__);
return &image->base;
}
cairo_surface_unmap_image (cairo_surface_t *surface,
cairo_surface_t *image)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
if (unlikely (surface->status)) {
if (unlikely (status))
_cairo_surface_set_error (surface, status);
+ CAIRO_TRACE_END (__func__);
return;
error:
_cairo_surface_set_error (surface, status);
cairo_surface_finish (image);
cairo_surface_destroy (image);
+ CAIRO_TRACE_END (__func__);
}
cairo_surface_t *
int height,
const cairo_color_t *color)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *surface;
cairo_status_t status;
cairo_solid_pattern_t pattern;
- if (unlikely (other->status))
+ if (unlikely (other->status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_create_in_error (other->status);
+ }
surface = NULL;
if (other->backend->create_similar)
_cairo_format_from_content (content),
width, height);
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface;
+ }
_cairo_surface_copy_similar_properties (surface, other);
- if (unlikely (surface->status))
+ if (unlikely (surface->status)){
+ CAIRO_TRACE_END (__func__);
return surface;
+ }
if (color) {
_cairo_pattern_init_solid (&pattern, color);
}
}
+ CAIRO_TRACE_END (__func__);
return surface;
}
void
cairo_surface_destroy (cairo_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
if (surface == NULL ||
- CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count))
+ CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count));
- if (! _cairo_reference_count_dec_and_test (&surface->ref_count))
+ if (! _cairo_reference_count_dec_and_test (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
assert (surface->snapshot_of == NULL);
/* We may have been referenced by a snapshot prior to have
* detaching it with the copy-on-write.
*/
- if (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count))
+ if (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
_cairo_surface_finish (surface);
}
assert (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count));
free (surface);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def(cairo_surface_destroy);
void
cairo_surface_finish (cairo_surface_t *surface)
{
- if (surface == NULL)
+ CAIRO_TRACE_BEGIN (__func__);
+ if (surface == NULL) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count))
+ if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (surface->finished)
+ if (surface->finished) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
/* We have to be careful when decoupling potential reference cycles */
cairo_surface_reference (surface);
_cairo_surface_finish (surface);
cairo_surface_destroy (surface);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_surface_finish);
const unsigned char **data,
unsigned long *length)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_user_data_slot_t *slots;
int i, num_slots;
*length = 0;
/* Prevent reads of the array during teardown */
- if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count))
+ if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
/* The number of mime-types attached to a surface is usually small,
* typically zero. Therefore it is quicker to do a strcmp() against
*data = mime_data->data;
*length = mime_data->length;
+ CAIRO_TRACE_END (__func__);
return;
}
}
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_surface_get_mime_data);
cairo_destroy_func_t destroy,
void *closure)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
cairo_mime_data_t *mime_data;
- if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count))
+ if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
+ }
- if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count))
+ if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
+ }
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
- if (unlikely (surface->finished))
+ }
+ if (unlikely (surface->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ }
status = _cairo_intern_string (&mime_type, -1);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
+ }
if (data != NULL) {
mime_data = malloc (sizeof (cairo_mime_data_t));
- if (unlikely (mime_data == NULL))
+ if (unlikely (mime_data == NULL)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_NO_MEMORY));
+ }
CAIRO_REFERENCE_COUNT_INIT (&mime_data->ref_count, 1);
_cairo_mime_data_destroy);
if (unlikely (status)) {
free (mime_data);
-
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
}
-
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
slim_hidden_def (cairo_surface_set_mime_data);
_cairo_surface_copy_mime_data (cairo_surface_t *dst,
cairo_surface_t *src)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (dst->status)
+ if (dst->status) {
+ CAIRO_TRACE_END (__func__);
return dst->status;
+ }
- if (src->status)
+ if (src->status) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (dst, src->status);
+ }
/* first copy the mime-data, discarding any already set on dst */
status = _cairo_user_data_array_copy (&dst->mime_data, &src->mime_data);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (dst, status);
+ }
/* now increment the reference counters for the copies */
_cairo_user_data_array_foreach (&dst->mime_data,
_cairo_mime_data_reference,
NULL);
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
void
cairo_surface_flush (cairo_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (surface->status)
+ if (surface->status) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (surface->finished)
+ if (surface->finished) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = _cairo_surface_flush (surface, 0);
if (unlikely (status))
_cairo_surface_set_error (surface, status);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_surface_flush);
cairo_image_surface_t **image_out,
void **image_extra)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
+ }
assert (!surface->finished);
- if (surface->backend->acquire_source_image == NULL)
+ if (surface->backend->acquire_source_image == NULL) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
status = surface->backend->acquire_source_image (surface,
image_out, image_extra);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
+ }
_cairo_debug_check_image_surface_is_defined (&(*image_out)->base);
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
cairo_image_surface_t **image_out,
void **image_extra)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_surface_t *surface = _surface;
cairo_rectangle_int_t extents;
- if (unlikely (! surface->backend->get_extents (surface, &extents)))
+ if (unlikely (! surface->backend->get_extents (surface, &extents))) {
+ CAIRO_TRACE_END (__func__);
return _cairo_error (CAIRO_STATUS_INVALID_SIZE);
+ }
*image_out = _cairo_surface_map_to_image (surface, &extents);
*image_extra = NULL;
+ CAIRO_TRACE_END (__func__);
return (*image_out)->base.status;
}
const cairo_pattern_t *source,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
- if (unlikely (surface->finished))
+ }
+ if (unlikely (surface->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ }
- if (_cairo_clip_is_all_clipped (clip))
+ if (_cairo_clip_is_all_clipped (clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _pattern_has_error (source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
- if (nothing_to_do (surface, op, source))
+ if (nothing_to_do (surface, op, source)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _cairo_surface_begin_modification (surface);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = surface->backend->paint (surface, op, source, clip);
if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
surface->serial++;
}
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
}
const cairo_pattern_t *mask,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
- if (unlikely (surface->finished))
+ }
+ if (unlikely (surface->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ }
- if (_cairo_clip_is_all_clipped (clip))
+ if (_cairo_clip_is_all_clipped (clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
/* If the mask is blank, this is just an expensive no-op */
if (_cairo_pattern_is_clear (mask) &&
_cairo_operator_bounded_by_mask (op))
{
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
}
status = _pattern_has_error (source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _pattern_has_error (mask);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
- if (nothing_to_do (surface, op, source))
+ if (nothing_to_do (surface, op, source)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _cairo_surface_begin_modification (surface);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = surface->backend->mask (surface, op, source, mask, clip);
if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
surface->serial++;
}
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
}
cairo_antialias_t stroke_antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
- if (unlikely (surface->finished))
- return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
-
- if (_cairo_clip_is_all_clipped (clip))
- return CAIRO_STATUS_SUCCESS;
+ }
- if (surface->is_clear &&
- fill_op == CAIRO_OPERATOR_CLEAR &&
- stroke_op == CAIRO_OPERATOR_CLEAR)
- {
- return CAIRO_STATUS_SUCCESS;
- }
+ if (unlikely (surface->finished)) {
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
+ return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ }
+ if (_cairo_clip_is_all_clipped (clip)) {
+ CAIRO_TRACE_END (__func__);
+ return CAIRO_STATUS_SUCCESS;
+ }
+
+ if (surface->is_clear &&
+ fill_op == CAIRO_OPERATOR_CLEAR &&
+ stroke_op == CAIRO_OPERATOR_CLEAR) {
+ CAIRO_TRACE_END (__func__);
+ return CAIRO_STATUS_SUCCESS;
+ }
+ }
- status = _pattern_has_error (fill_source);
- if (unlikely (status))
+ status = _pattern_has_error (fill_source);
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _pattern_has_error (stroke_source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = _cairo_surface_begin_modification (surface);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (surface->backend->fill_stroke) {
cairo_matrix_t dev_ctm = *stroke_ctm;
surface->serial++;
}
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
- if (unlikely (surface->finished))
+ }
+ if (unlikely (surface->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ }
- if (_cairo_clip_is_all_clipped (clip))
+ if (_cairo_clip_is_all_clipped (clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _pattern_has_error (source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
- if (nothing_to_do (surface, op, source))
+ if (nothing_to_do (surface, op, source)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _cairo_surface_begin_modification (surface);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = surface->backend->stroke (surface, op, source,
path, stroke_style,
surface->serial++;
}
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
}
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return surface->status;
- if (unlikely (surface->finished))
+ }
+ if (unlikely (surface->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
-
- if (_cairo_clip_is_all_clipped (clip))
+ }
+ if (_cairo_clip_is_all_clipped (clip)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _pattern_has_error (source);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
- if (nothing_to_do (surface, op, source))
+ if (nothing_to_do (surface, op, source)) {
+ CAIRO_TRACE_END (__func__);
return CAIRO_STATUS_SUCCESS;
+ }
status = _cairo_surface_begin_modification (surface);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = surface->backend->fill (surface, op, source,
path, fill_rule,
surface->serial++;
}
+ CAIRO_TRACE_END (__func__);
return _cairo_surface_set_error (surface, status);
}
void
cairo_surface_copy_page (cairo_surface_t *surface)
{
- if (unlikely (surface->status))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
assert (surface->snapshot_of == NULL);
if (unlikely (surface->finished)) {
_cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
+ CAIRO_TRACE_END (__func__);
return;
}
/* It's fine if some backends don't implement copy_page */
- if (surface->backend->copy_page == NULL)
+ if (surface->backend->copy_page == NULL) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
+ CAIRO_TRACE_END (__func__);
_cairo_surface_set_error (surface, surface->backend->copy_page (surface));
}
slim_hidden_def (cairo_surface_copy_page);
void
cairo_surface_show_page (cairo_surface_t *surface)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (surface->status))
+ if (unlikely (surface->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (unlikely (surface->finished)) {
_cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
+ CAIRO_TRACE_END (__func__);
return;
}
status = _cairo_surface_begin_modification (surface);
if (unlikely (status)) {
_cairo_surface_set_error (surface, status);
+ CAIRO_TRACE_END (__func__);
return;
}
/* It's fine if some backends don't implement show_page */
- if (surface->backend->show_page == NULL)
+ if (surface->backend->show_page == NULL) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
+ CAIRO_TRACE_END (__func__);
_cairo_surface_set_error (surface, surface->backend->show_page (surface));
}
slim_hidden_def (cairo_surface_show_page);
#include "cairo-spans-private.h"
#include "cairo-traps-private.h"
#include "cairo-tristrip-private.h"
+#include "cairo-ttrace.h"
typedef cairo_int_status_t
(*draw_func_t) (const cairo_traps_compositor_t *compositor,
_cairo_traps_compositor_paint (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t*)_compositor;
cairo_boxes_t boxes;
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
status = compositor->check_composite (extents);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
_cairo_clip_steal_boxes (extents->clip, &boxes);
status = clip_and_composite_boxes (compositor, extents, &boxes);
_cairo_clip_unsteal_boxes (extents->clip, &boxes);
+ CAIRO_TRACE_END (__func__);
return status;
}
_cairo_traps_compositor_mask (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents)
{
+ CAIRO_TRACE_BEGIN (__func__);
const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t*)_compositor;
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
status = compositor->check_composite (extents);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
if (extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&
extents->clip->path == NULL) {
&extents->mask_sample_area,
&data.mask_x,
&data.mask_y);
- if (unlikely (data.mask->status))
+ if (unlikely (data.mask->status)) {
+ CAIRO_TRACE_END (__func__);
return data.mask->status;
+ }
status = clip_and_composite (compositor, extents,
composite_mask,
cairo_surface_destroy (data.mask);
}
+ CAIRO_TRACE_END (__func__);
return status;
}
double tolerance,
cairo_antialias_t antialias)
{
+ CAIRO_TRACE_BEGIN (__func__);
const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t *)_compositor;
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
status = compositor->check_composite (extents);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = CAIRO_INT_STATUS_UNSUPPORTED;
if (_cairo_path_fixed_stroke_is_rectilinear (path)) {
_cairo_traps_fini (&info.traps);
}
+ CAIRO_TRACE_END (__func__);
return status;
}
double tolerance,
cairo_antialias_t antialias)
{
+ CAIRO_TRACE_BEGIN (__func__);
const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t *)_compositor;
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
status = compositor->check_composite (extents);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
status = CAIRO_INT_STATUS_UNSUPPORTED;
if (_cairo_path_fixed_fill_is_rectilinear (path)) {
_cairo_polygon_fini (&polygon);
}
+ CAIRO_TRACE_END (__func__);
return status;
}
int num_glyphs,
cairo_bool_t overlap)
{
+ CAIRO_TRACE_BEGIN (__func__);
const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t *)_compositor;
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
status = compositor->check_composite (extents);
- if (unlikely (status))
+ if (unlikely (status)) {
+ CAIRO_TRACE_END (__func__);
return status;
+ }
_cairo_scaled_font_freeze_cache (scaled_font);
status = compositor->check_composite_glyphs (extents,
}
_cairo_scaled_font_thaw_cache (scaled_font);
+ CAIRO_TRACE_END (__func__);
return status;
}
--- /dev/null
+/* Cairo - a vector graphics library with display and print output
+ *
+ * Copyright © 2009 Chris Wilson
+ * Copyright © 2014 Samsung Electronics
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ *
+ * The Original Code is the cairo graphics library.
+ *
+ */
+
+
+#ifdef CAIRO_HAS_TTRACE
+#include <ttrace.h>
+//#define CAIRO_TRACE_BEGIN(NAME) traceBegin(TTRACE_TAG_GRAPHICS, NAME)
+//#define CAIRO_TRACE_END() traceEnd(TTRACE_TAG_GRAPHICS)
+#define CAIRO_TRACE_BEGIN(NAME) traceAsyncBegin (TTRACE_TAG_GRAPHICS, 0, NAME);
+#define CAIRO_TRACE_END(NAME) traceAsyncEnd(TTRACE_TAG_GRAPHICS, 0, NAME);
+#else
+#define CAIRO_TRACE_BEGIN(NAME)
+#define CAIRO_TRACE_END(NAME)
+#define CAIRO_TRACE_ASYNC_BEGIN(NAME, KEY)
+#define CAIRO_TRACE_ASYNC_END(NAME, KEY)
+#endif
+
+
#include "cairo-surface-backend-private.h"
#include <assert.h>
+#include "cairo-ttrace.h"
/**
* SECTION:cairo
cairo_t *
cairo_create (cairo_surface_t *target)
{
- if (unlikely (target == NULL))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (unlikely (target == NULL)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NULL_POINTER));
- if (unlikely (target->status))
+ }
+ if (unlikely (target->status)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_create_in_error (target->status);
- if (unlikely (target->finished))
+ }
+ if (unlikely (target->finished)) {
+ CAIRO_TRACE_END (__func__);
return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ }
- if (target->backend->create_context == NULL)
+ if (target->backend->create_context == NULL) {
+ CAIRO_TRACE_END (__func__);
return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_WRITE_ERROR));
+ }
- return target->backend->create_context (target);
+ cairo_t *cr = target->backend->create_context (target);
+ CAIRO_TRACE_END (__func__);
+ return cr;
}
slim_hidden_def (cairo_create);
void
cairo_destroy (cairo_t *cr)
{
- if (cr == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&cr->ref_count))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (cr == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&cr->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&cr->ref_count));
- if (! _cairo_reference_count_dec_and_test (&cr->ref_count))
+ if (! _cairo_reference_count_dec_and_test (&cr->ref_count)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
cr->backend->destroy (cr);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_destroy);
void
cairo_save (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->save (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def(cairo_save);
void
cairo_restore (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->restore (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def(cairo_restore);
void
cairo_set_source_rgb (cairo_t *cr, double red, double green, double blue)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->set_source_rgba (cr, red, green, blue, 1.);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_set_source_rgb);
double x,
double y)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (unlikely (surface == NULL)) {
_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
+ CAIRO_TRACE_END (__func__);
return;
}
status = cr->backend->set_source_surface (cr, surface, x, y);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_set_source_surface);
void
cairo_translate (cairo_t *cr, double tx, double ty)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->translate (cr, tx, ty);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_translate);
void
cairo_scale (cairo_t *cr, double sx, double sy)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->scale (cr, sx, sy);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_scale);
void
cairo_rotate (cairo_t *cr, double angle)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->rotate (cr, angle);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_user_to_device (cairo_t *cr, double *x, double *y)
{
- if (unlikely (cr->status))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
cr->backend->user_to_device (cr, x, y);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_user_to_device);
void
cairo_user_to_device_distance (cairo_t *cr, double *dx, double *dy)
{
- if (unlikely (cr->status))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
cr->backend->user_to_device_distance (cr, dx, dy);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_user_to_device_distance);
void
cairo_device_to_user (cairo_t *cr, double *x, double *y)
{
- if (unlikely (cr->status))
+ CAIRO_TRACE_BEGIN (__func__);
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
cr->backend->device_to_user (cr, x, y);
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_device_to_user);
double radius,
double angle1, double angle2)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (angle2 < angle1) {
/* increase angle2 by multiples of full circle until it
status = cr->backend->arc (cr, xc, yc, radius, angle1, angle2, TRUE);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
double radius,
double angle1, double angle2)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (angle2 > angle1) {
/* decrease angle2 by multiples of full circle until it
status = cr->backend->arc (cr, xc, yc, radius, angle1, angle2, FALSE);
if (unlikely (status))
_cairo_set_error (cr, status);
+ CAIRO_TRACE_END (__func__);
}
/* XXX: NYI
double x, double y,
double width, double height)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->rectangle (cr, x, y, width, height);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
double r_top_left, double r_top_right,
double r_bottom_left, double r_bottom_right)
{
- cairo_status_t status;
+ CAIRO_TRACE_BEGIN (__func__);
+ cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->rounded_rectangle (cr, x, y, width, height,
r_top_left, r_top_right,
r_bottom_left, r_bottom_right);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
#if 0
void
cairo_paint (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->paint (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_paint);
cairo_paint_with_alpha (cairo_t *cr,
double alpha)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->paint_with_alpha (cr, alpha);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
cairo_mask (cairo_t *cr,
cairo_pattern_t *pattern)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (unlikely (pattern == NULL)) {
_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
+ CAIRO_TRACE_END (__func__);
return;
}
if (unlikely (pattern->status)) {
_cairo_set_error (cr, pattern->status);
+ CAIRO_TRACE_END (__func__);
return;
}
status = cr->backend->mask (cr, pattern);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def (cairo_mask);
double surface_x,
double surface_y)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
pattern = cairo_pattern_create_for_surface (surface);
cairo_mask (cr, pattern);
cairo_pattern_destroy (pattern);
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_stroke (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->stroke (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def(cairo_stroke);
void
cairo_stroke_preserve (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->stroke_preserve (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def(cairo_stroke_preserve);
void
cairo_fill (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->fill (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_fill_preserve (cairo_t *cr)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->fill_preserve (cr);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
slim_hidden_def(cairo_fill_preserve);
cairo_stroke_extents (cairo_t *cr,
double *x1, double *y1, double *x2, double *y2)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
if (unlikely (cr->status)) {
if (y2)
*y2 = 0.0;
+ CAIRO_TRACE_END (__func__);
return;
}
status = cr->backend->stroke_extents (cr, x1, y1, x2, y2);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
cairo_fill_extents (cairo_t *cr,
double *x1, double *y1, double *x2, double *y2)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
if (unlikely (cr->status)) {
if (y2)
*y2 = 0.0;
+ CAIRO_TRACE_END (__func__);
return;
}
status = cr->backend->fill_extents (cr, x1, y1, x2, y2);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
double *x1, double *y1,
double *x2, double *y2)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
if (x1)
if (y2)
*y2 = 0.0;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->clip_extents (cr, x1, y1, x2, y2);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_show_text (cairo_t *cr, const char *utf8)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_text_extents_t extents;
cairo_status_t status;
cairo_glyph_t *glyphs, *last_glyph;
cairo_scaled_font_t *scaled_font;
cairo_glyph_text_info_t info, *i;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (utf8 == NULL)
+ if (utf8 == NULL) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
scaled_font = cairo_get_scaled_font (cr);
if (unlikely (scaled_font->status)) {
_cairo_set_error (cr, scaled_font->status);
+ CAIRO_TRACE_END (__func__);
return;
}
if (unlikely (status))
goto BAIL;
- if (num_glyphs == 0)
+ if (num_glyphs == 0) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
i = NULL;
if (has_show_text_glyphs) {
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_show_glyphs (cairo_t *cr, const cairo_glyph_t *glyphs, int num_glyphs)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (num_glyphs == 0)
+ if (num_glyphs == 0) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (num_glyphs < 0) {
_cairo_set_error (cr, CAIRO_STATUS_NEGATIVE_COUNT);
+ CAIRO_TRACE_END (__func__);
return;
}
if (glyphs == NULL) {
_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
+ CAIRO_TRACE_END (__func__);
return;
}
status = cr->backend->glyphs (cr, glyphs, num_glyphs, NULL);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
int num_clusters,
cairo_text_cluster_flags_t cluster_flags)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
/* A slew of sanity checks */
(utf8_len && utf8 == NULL) ||
(num_clusters && clusters == NULL)) {
_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
+ CAIRO_TRACE_END (__func__);
return;
}
/* Apart from that, no negatives */
if (num_glyphs < 0 || utf8_len < 0 || num_clusters < 0) {
_cairo_set_error (cr, CAIRO_STATUS_NEGATIVE_COUNT);
+ CAIRO_TRACE_END (__func__);
return;
}
- if (num_glyphs == 0 && utf8_len == 0)
+ if (num_glyphs == 0 && utf8_len == 0) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (utf8) {
/* Make sure clusters cover the entire glyphs and utf8 arrays,
}
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_text_path (cairo_t *cr, const char *utf8)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
cairo_text_extents_t extents;
cairo_glyph_t stack_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
int num_glyphs;
double x, y;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (utf8 == NULL)
+ if (utf8 == NULL) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
glyphs = stack_glyphs;
scaled_font = cairo_get_scaled_font (cr);
if (unlikely (scaled_font->status)) {
_cairo_set_error (cr, scaled_font->status);
+ CAIRO_TRACE_END (__func__);
return;
}
&glyphs, &num_glyphs,
NULL, NULL, NULL);
- if (num_glyphs == 0)
+ if (num_glyphs == 0) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
status = cr->backend->glyph_path (cr, glyphs, num_glyphs);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
void
cairo_glyph_path (cairo_t *cr, const cairo_glyph_t *glyphs, int num_glyphs)
{
+ CAIRO_TRACE_BEGIN (__func__);
cairo_status_t status;
- if (unlikely (cr->status))
+ if (unlikely (cr->status)) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
- if (num_glyphs == 0)
+ if (num_glyphs == 0) {
+ CAIRO_TRACE_END (__func__);
return;
+ }
if (unlikely (num_glyphs < 0)) {
_cairo_set_error (cr, CAIRO_STATUS_NEGATIVE_COUNT);
+ CAIRO_TRACE_END (__func__);
return;
}
if (unlikely (glyphs == NULL)) {
_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
+ CAIRO_TRACE_END (__func__);
return;
}
status = cr->backend->glyph_path (cr, glyphs, num_glyphs);
if (unlikely (status))
_cairo_set_error (cr, status);
+
+ CAIRO_TRACE_END (__func__);
}
/**
projects / platform / core / graphics / cairo.git / commitdiff