summaryrefslogtreecommitdiff
path: root/common/cairo_canvas.c
diff options
context:
space:
mode:
Diffstat (limited to 'common/cairo_canvas.c')
-rw-r--r--common/cairo_canvas.c1664
1 files changed, 1664 insertions, 0 deletions
diff --git a/common/cairo_canvas.c b/common/cairo_canvas.c
new file mode 100644
index 00000000..732df919
--- /dev/null
+++ b/common/cairo_canvas.c
@@ -0,0 +1,1664 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "cairo_canvas.h"
+#include "canvas_base.c"
+#include "rop3.h"
+#include "rect.h"
+#include "region.h"
+
+struct CairoCanvas {
+ CanvasBase base;
+ cairo_t *cairo;
+ uint32_t *private_data;
+ int private_data_size;
+};
+
+static void canvas_set_path(CairoCanvas *canvas, void *addr)
+{
+ cairo_t *cairo = canvas->cairo;
+ uint32_t* data_size = (uint32_t*)addr;
+ access_test(&canvas->base, data_size, sizeof(uint32_t));
+ uint32_t more = *data_size;
+
+ PathSeg* seg = (PathSeg*)(data_size + 1);
+
+ do {
+ access_test(&canvas->base, seg, sizeof(PathSeg));
+
+ uint32_t flags = seg->flags;
+ PointFix* point = (PointFix*)seg->data;
+ PointFix* end_point = point + seg->count;
+ access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
+ ASSERT(point < end_point);
+ more -= ((unsigned long)end_point - (unsigned long)seg);
+ seg = (PathSeg*)end_point;
+
+ if (flags & PATH_BEGIN) {
+ cairo_new_sub_path(cairo);
+ cairo_move_to(cairo, fix_to_double(point->x), fix_to_double(point->y));
+ point++;
+ }
+
+ if (flags & PATH_BEZIER) {
+ ASSERT((point - end_point) % 3 == 0);
+ for (; point + 2 < end_point; point += 3) {
+ cairo_curve_to(cairo,
+ fix_to_double(point[0].x), fix_to_double(point[0].y),
+ fix_to_double(point[1].x), fix_to_double(point[1].y),
+ fix_to_double(point[2].x), fix_to_double(point[2].y));
+ }
+ } else {
+ for (; point < end_point; point++) {
+ cairo_line_to(cairo, fix_to_double(point->x), fix_to_double(point->y));
+ }
+ }
+ if (flags & PATH_END) {
+ if (flags & PATH_CLOSE) {
+ cairo_close_path(cairo);
+ }
+ cairo_new_sub_path(cairo);
+ }
+ } while (more);
+}
+
+static void canvas_clip(CairoCanvas *canvas, Clip *clip)
+{
+ cairo_t *cairo = canvas->cairo;
+
+ switch (clip->type) {
+ case CLIP_TYPE_NONE:
+ break;
+ case CLIP_TYPE_RECTS: {
+ uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+ access_test(&canvas->base, n, sizeof(uint32_t));
+
+ Rect *now = (Rect *)(n + 1);
+ Rect *end = now + *n;
+ access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
+
+ for (; now < end; now++) {
+ cairo_rectangle(cairo, now->left, now->top, now->right - now->left,
+ now->bottom - now->top);
+ }
+ cairo_clip(cairo);
+ break;
+ }
+ case CLIP_TYPE_PATH:
+ canvas_set_path(canvas, GET_ADDRESS(clip->data));
+ cairo_clip(cairo);
+ break;
+ default:
+ CANVAS_ERROR("invalid clip type");
+ }
+}
+
+static inline cairo_line_cap_t canvas_line_cap_to_cairo(int end_style)
+{
+ switch (end_style) {
+ case LINE_CAP_ROUND:
+ return CAIRO_LINE_CAP_ROUND;
+ case LINE_CAP_SQUARE:
+ return CAIRO_LINE_CAP_SQUARE;
+ case LINE_CAP_BUTT:
+ return CAIRO_LINE_CAP_BUTT;
+ default:
+ CANVAS_ERROR("bad end style %d", end_style);
+ }
+}
+
+static inline cairo_line_join_t canvas_line_join_to_cairo(int join_style)
+{
+ switch (join_style) {
+ case LINE_JOIN_ROUND:
+ return CAIRO_LINE_JOIN_ROUND;
+ case LINE_JOIN_BEVEL:
+ return CAIRO_LINE_JOIN_BEVEL;
+ case LINE_JOIN_MITER:
+ return CAIRO_LINE_JOIN_MITER;
+ default:
+ CANVAS_ERROR("bad join style %d", join_style);
+ }
+}
+
+static void canvas_set_line_attr_no_dash(CairoCanvas *canvas, LineAttr *attr)
+{
+ cairo_t *cairo = canvas->cairo;
+
+ cairo_set_line_width(cairo, fix_to_double(attr->width));
+ cairo_set_line_cap(cairo, canvas_line_cap_to_cairo(attr->end_style));
+ cairo_set_line_join(cairo, canvas_line_join_to_cairo(attr->join_style));
+ cairo_set_miter_limit(cairo, fix_to_double(attr->miter_limit));
+ cairo_set_dash(cairo, NULL, 0, 0);
+}
+
+static void canvas_set_dash(CairoCanvas *canvas, UINT8 nseg, ADDRESS addr, int start_is_gap)
+{
+ FIXED28_4* style = (FIXED28_4*)GET_ADDRESS(addr);
+ double offset = 0;
+ double *local_style;
+ int i;
+
+ access_test(&canvas->base, style, nseg * sizeof(*style));
+
+ if (nseg == 0) {
+ CANVAS_ERROR("bad nseg");
+ }
+ local_style = (double *)malloc(nseg * sizeof(*local_style));
+
+ if (start_is_gap) {
+ offset = fix_to_double(*style);
+ local_style[nseg - 1] = fix_to_double(*style);
+ style++;
+
+ for (i = 0; i < nseg - 1; i++, style++) {
+ local_style[i] = fix_to_double(*style);
+ }
+ } else {
+ for (i = 0; i < nseg; i++, style++) {
+ local_style[i] = fix_to_double(*style);
+ }
+ }
+ cairo_set_dash(canvas->cairo, local_style, nseg, offset);
+ free(local_style);
+}
+
+static inline void canvas_invers_32bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+ int width, uint8_t *end)
+{
+ for (; src != end; src += src_stride, dest += dest_stride) {
+ uint32_t *src_line = (uint32_t *)src;
+ uint32_t *src_line_end = src_line + width;
+ uint32_t *dest_line = (uint32_t *)dest;
+
+ while (src_line < src_line_end) {
+ *(dest_line++) = ~*(src_line++) & 0x00ffffff;
+ }
+ }
+}
+
+static inline void canvas_invers_24bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+ int width, uint8_t *end)
+{
+ for (; src != end; src += src_stride, dest += dest_stride) {
+ uint8_t *src_line = src;
+ uint8_t *src_line_end = src_line + width * 3;
+ uint8_t *dest_line = dest;
+
+ for (; src_line < src_line_end; ++dest_line) {
+ *(dest_line++) = ~*(src_line++);
+ *(dest_line++) = ~*(src_line++);
+ *(dest_line++) = ~*(src_line++);
+ }
+ }
+}
+
+static inline void canvas_invers_16bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+ int width, uint8_t *end)
+{
+ for (; src != end; src += src_stride, dest += dest_stride) {
+ uint16_t *src_line = (uint16_t*)src;
+ uint16_t *src_line_end = src_line + width;
+ uint32_t *dest_line = (uint32_t*)dest;
+
+ for (; src_line < src_line_end; ++dest_line, src_line++) {
+ *dest_line = ~canvas_16bpp_to_32bpp(*src_line) & 0x00ffffff;
+ }
+ }
+}
+
+static inline void canvas_invers_8bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+ int width, uint8_t *end, Palette *palette)
+{
+ if (!palette) {
+ CANVAS_ERROR("no palette");
+ }
+
+ for (; src != end; src += src_stride, dest += dest_stride) {
+ uint32_t *dest_line = (uint32_t*)dest;
+ uint8_t *src_line = src;
+ uint8_t *src_line_end = src_line + width;
+
+ while (src_line < src_line_end) {
+ ASSERT(*src_line < palette->num_ents);
+ *(dest_line++) = ~palette->ents[*(src_line++)] & 0x00ffffff;
+ }
+ }
+}
+
+static inline void canvas_invers_4bpp_be(uint8_t* dest, int dest_stride, uint8_t* src,
+ int src_stride, int width, uint8_t* end,
+ Palette *palette)
+{
+ if (!palette) {
+ CANVAS_ERROR("no palette");
+ }
+
+ for (; src != end; src += src_stride, dest += dest_stride) {
+ uint32_t *dest_line = (uint32_t *)dest;
+ uint8_t *now = src;
+ int i;
+
+ for (i = 0; i < (width >> 1); i++) {
+ ASSERT((*now & 0x0f) < palette->num_ents);
+ ASSERT(((*now >> 4) & 0x0f) < palette->num_ents);
+ *(dest_line++) = ~palette->ents[(*now >> 4) & 0x0f] & 0x00ffffff;
+ *(dest_line++) = ~palette->ents[*(now++) & 0x0f] & 0x00ffffff;
+ }
+ if (width & 1) {
+ *(dest_line) = ~palette->ents[(*src >> 4) & 0x0f] & 0x00ffffff;
+ }
+ }
+}
+
+static inline void canvas_invers_1bpp_be(uint8_t* dest, int dest_stride, uint8_t* src,
+ int src_stride, int width, uint8_t* end,
+ Palette *palette)
+{
+ uint32_t fore_color;
+ uint32_t back_color;
+
+ if (!palette) {
+ CANVAS_ERROR("no palette");
+ }
+
+ fore_color = palette->ents[1];
+ back_color = palette->ents[0];
+
+ for (; src != end; src += src_stride, dest += dest_stride) {
+ uint32_t* dest_line = (uint32_t*)dest;
+ int i;
+
+ for (i = 0; i < width; i++) {
+ if (test_bit_be(src, i)) {
+ *(dest_line++) = ~fore_color & 0x00ffffff;
+ } else {
+ *(dest_line++) = ~back_color & 0x00ffffff;
+ }
+ }
+ }
+}
+
+static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, Bitmap* bitmap,
+ Palette *palette)
+{
+ uint8_t* src = (uint8_t *)GET_ADDRESS(bitmap->data);
+ int src_stride;
+ uint8_t* end;
+ uint8_t* dest;
+ int dest_stride;
+ cairo_surface_t* cairo_surface;
+
+ src_stride = bitmap->stride;
+ end = src + (bitmap->y * src_stride);
+ access_test(&canvas->base, src, bitmap->y * src_stride);
+
+ cairo_surface = cairo_image_surface_create((bitmap->format == BITMAP_FMT_RGBA) ?
+ CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
+ bitmap->x, bitmap->y);
+ if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
+ CANVAS_ERROR("create surface failed, %s",
+ cairo_status_to_string(cairo_surface_status(cairo_surface)));
+ }
+ dest = cairo_image_surface_get_data(cairo_surface);
+ dest_stride = cairo_image_surface_get_stride(cairo_surface);
+
+ if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+ ASSERT(bitmap->y > 0);
+ dest += dest_stride * (bitmap->y - 1);
+ dest_stride = -dest_stride;
+ }
+ switch (bitmap->format) {
+ case BITMAP_FMT_32BIT:
+ case BITMAP_FMT_RGBA:
+ canvas_invers_32bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+ break;
+ case BITMAP_FMT_24BIT:
+ canvas_invers_24bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+ break;
+ case BITMAP_FMT_16BIT:
+ canvas_invers_16bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+ break;
+ case BITMAP_FMT_8BIT:
+ canvas_invers_8bpp(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+ break;
+ case BITMAP_FMT_4BIT_BE:
+ canvas_invers_4bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+ break;
+ case BITMAP_FMT_1BIT_BE:
+ canvas_invers_1bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+ break;
+ }
+ return cairo_surface;
+}
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+
+#ifndef CAIRO_CANVAS_CACHE
+static Palette *canvas_get_palette(CairoCanvas *canvas, Bitmap *bitmap)
+{
+ Palette *local_palette;
+ Palette *palette;
+ int size;
+
+ if (!bitmap->palette) {
+ return NULL;
+ }
+
+ palette = (Palette *)GET_ADDRESS(bitmap->palette);
+ if (canvas->base.color_shift != 5) {
+ return palette;
+ }
+
+ size = sizeof(Palette) + (palette->num_ents << 2);
+ local_palette = malloc(size);
+ memcpy(local_palette, palette, size);
+ canvas_localize_palette(&canvas->base, palette);
+
+ return local_palette;
+}
+
+static void free_palette(Bitmap *bitmap, Palette *palette)
+{
+ if (!palette || palette == GET_ADDRESS(bitmap->palette)) {
+ return;
+ }
+ free(palette);
+}
+
+#endif
+
+static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS addr)
+{
+ ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+ cairo_surface_t *surface;
+ cairo_surface_t *invers = NULL;
+
+ access_test(&canvas->base, descriptor, sizeof(ImageDescriptor));
+
+ int cache_me = descriptor->flags & IMAGE_CACHE_ME;
+
+ switch (descriptor->type) {
+ case IMAGE_TYPE_QUIC: {
+ QUICImage *image = (QUICImage *)descriptor;
+ access_test(&canvas->base, descriptor, sizeof(QUICImage));
+ if (cache_me) {
+ surface = canvas_get_quic(&canvas->base, image, 0);
+ } else {
+ return canvas_get_quic(&canvas->base, image, 1);
+ }
+ break;
+ }
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+ case IMAGE_TYPE_LZ_PLT: {
+ access_test(&canvas->base, descriptor, sizeof(LZ_PLTImage));
+ LZImage *image = (LZImage *)descriptor;
+ if (cache_me) {
+ surface = canvas_get_lz(&canvas->base, image, 0);
+ } else {
+ return canvas_get_lz(&canvas->base, image, 1);
+ }
+ break;
+ }
+ case IMAGE_TYPE_LZ_RGB: {
+ access_test(&canvas->base, descriptor, sizeof(LZ_RGBImage));
+ LZImage *image = (LZImage *)descriptor;
+ if (cache_me) {
+ surface = canvas_get_lz(&canvas->base, image, 0);
+ } else {
+ return canvas_get_lz(&canvas->base, image, 1);
+ }
+ break;
+ }
+#endif
+#ifdef USE_GLZ
+ case IMAGE_TYPE_GLZ_RGB: {
+ access_test(&canvas->base, descriptor, sizeof(LZ_RGBImage));
+ LZImage *image = (LZImage *)descriptor;
+ surface = canvas_get_glz(&canvas->base, image);
+ break;
+ }
+#endif
+ case IMAGE_TYPE_FROM_CACHE:
+ surface = canvas->base.bits_cache_get(canvas->base.bits_cache_opaque, descriptor->id);
+ break;
+ case IMAGE_TYPE_BITMAP: {
+ BitmapImage *bitmap = (BitmapImage *)descriptor;
+ access_test(&canvas->base, descriptor, sizeof(BitmapImage));
+ if (cache_me) {
+ surface = canvas_get_bits(&canvas->base, &bitmap->bitmap);
+ } else {
+#ifdef CAIRO_CANVAS_CACHE
+ return canvas_bitmap_to_invers_surface(canvas, &bitmap->bitmap,
+ canvas_get_palett(&canvas->base,
+ bitmap->bitmap.palette,
+ bitmap->bitmap.flags));
+#else
+ Palette *palette = canvas_get_palette(canvas, &bitmap->bitmap);
+ surface = canvas_bitmap_to_invers_surface(canvas, &bitmap->bitmap, palette);
+ free_palette(&bitmap->bitmap, palette);
+ return surface;
+#endif
+ }
+ break;
+ }
+ default:
+ CANVAS_ERROR("invalid image type");
+ }
+
+ if (cache_me) {
+ canvas->base.bits_cache_put(canvas->base.bits_cache_opaque, descriptor->id, surface);
+ }
+
+ invers = canvas_handle_inverse_user_data(surface);
+ cairo_surface_destroy(surface);
+ return invers;
+}
+
+#else
+
+static cairo_surface_t *canvas_get_invers(CairoCanvas *canvas, Bitmap *bitmap)
+{
+ Palette *palette;
+
+ if (!bitmap->palette) {
+ return canvas_bitmap_to_invers_surface(canvas, bitmap, NULL);
+ }
+ palette = (Palette *)GET_ADDRESS(bitmap->palette);
+ if (canvas->color_shift == 5) {
+ int size = sizeof(Palette) + (palette->num_ents << 2);
+ Palette *local_palette = malloc(size);
+ cairo_surface_t* surface;
+
+ memcpy(local_palette, palette, size);
+ canvas_localize_palette(canvas, palette);
+ surface = canvas_bitmap_to_invers_surface(canvas, bitmap, local_palette);
+ free(local_palette);
+ return surface;
+ } else {
+ return canvas_bitmap_to_invers_surface(canvas, bitmap, palette);
+ }
+}
+
+static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS addr)
+{
+ ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+
+ access_test(canvas, descriptor, sizeof(ImageDescriptor));
+
+ switch (descriptor->type) {
+ case IMAGE_TYPE_QUIC: {
+ QUICImage *image = (QUICImage *)descriptor;
+ access_test(canvas, descriptor, sizeof(QUICImage));
+ return canvas_get_quic(canvas, image, 1);
+ }
+ case IMAGE_TYPE_BITMAP: {
+ BitmapImage *bitmap = (BitmapImage *)descriptor;
+ access_test(canvas, descriptor, sizeof(BitmapImage));
+ return canvas_get_invers(canvas, &bitmap->bitmap);
+ }
+ default:
+ CANVAS_ERROR("invalid image type");
+ }
+}
+
+#endif
+
+static cairo_surface_t* canvas_surface_from_self(CairoCanvas *canvas, Point *pos,
+ int32_t width, int32_t heigth)
+{
+ cairo_surface_t *surface;
+ cairo_surface_t *src_surface;
+ uint8_t *dest;
+ int dest_stride;
+ uint8_t *src;
+ int src_stride;
+ int i;
+
+ surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, heigth);
+ if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+ CANVAS_ERROR("create surface failed, %s",
+ cairo_status_to_string(cairo_surface_status(surface)));
+ }
+ dest = cairo_image_surface_get_data(surface);
+ dest_stride = cairo_image_surface_get_stride(surface);
+
+ src_surface = cairo_get_target(canvas->cairo);
+ src = cairo_image_surface_get_data(src_surface);
+ src_stride = cairo_image_surface_get_stride(src_surface);
+ src += pos->y * src_stride + (pos->x << 2);
+ for (i = 0; i < heigth; i++, dest += dest_stride, src += src_stride) {
+ memcpy(dest, src, width << 2);
+ }
+ return surface;
+}
+
+static cairo_pattern_t *canvas_get_brush(CairoCanvas *canvas, Brush *brush, uint32_t invers)
+{
+ switch (brush->type) {
+ case BRUSH_TYPE_SOLID: {
+ uint32_t color = (invers) ? ~brush->u.color : brush->u.color;
+ double r, g, b;
+
+ b = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+ color >>= canvas->base.color_shift;
+ g = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+ color >>= canvas->base.color_shift;
+ r = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+ return cairo_pattern_create_rgb(r, g, b);
+ }
+ case BRUSH_TYPE_PATTERN: {
+ cairo_surface_t* surface;
+ cairo_pattern_t *pattern;
+ cairo_matrix_t matrix;
+
+ if (invers) {
+ surface = canvas_get_invers_image(canvas, brush->u.pattern.pat);
+ } else {
+ surface = canvas_get_image(&canvas->base, brush->u.pattern.pat);
+ }
+ pattern = cairo_pattern_create_for_surface(surface);
+ if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+ cairo_surface_destroy(surface);
+ CANVAS_ERROR("create pattern failed, %s",
+ cairo_status_to_string(cairo_pattern_status(pattern)));
+ }
+ cairo_surface_destroy(surface);
+ cairo_matrix_init_translate(&matrix, -brush->u.pattern.pos.x, -brush->u.pattern.pos.y);
+ cairo_pattern_set_matrix(pattern, &matrix);
+ cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
+ return pattern;
+ }
+ case BRUSH_TYPE_NONE:
+ return NULL;
+ default:
+ CANVAS_ERROR("invalid brush type");
+ }
+}
+
+typedef void (*DrawMethod)(void *);
+
+static inline void __canvas_draw_invers(CairoCanvas *canvas, DrawMethod draw_method, void *data)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_set_source_rgb(cairo, 1, 1, 1);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_XOR);
+ draw_method(data);
+}
+
+static inline int canvas_set_ropd_operator(cairo_t *cairo, uint16_t rop_decriptor)
+{
+ cairo_operator_t cairo_op;
+
+ if (rop_decriptor & ROPD_OP_PUT) {
+ cairo_op = CAIRO_OPERATOR_RASTER_COPY;
+ } else if (rop_decriptor & ROPD_OP_XOR) {
+ cairo_op = CAIRO_OPERATOR_RASTER_XOR;
+ } else if (rop_decriptor & ROPD_OP_OR) {
+ cairo_op = CAIRO_OPERATOR_RASTER_OR;
+ } else if (rop_decriptor & ROPD_OP_AND) {
+ cairo_op = CAIRO_OPERATOR_RASTER_AND;
+ } else {
+ return 0;
+ }
+ cairo_set_operator(cairo, cairo_op);
+ return 1;
+}
+
+static void canvas_draw_with_pattern(CairoCanvas *canvas, cairo_pattern_t *pattern,
+ uint16_t rop_decriptor,
+ DrawMethod draw_method, void *data)
+{
+ cairo_t *cairo = canvas->cairo;
+
+ if (rop_decriptor & ROPD_OP_BLACKNESS) {
+ cairo_set_source_rgb(cairo, 0, 0, 0);
+ draw_method(data);
+ } else if (rop_decriptor & ROPD_OP_WHITENESS) {
+ cairo_set_source_rgb(cairo, 1, 1, 1);
+ draw_method(data);
+ } else if (rop_decriptor & ROPD_OP_INVERS) {
+ __canvas_draw_invers(canvas, draw_method, data);
+ } else {
+ if (rop_decriptor & ROPD_INVERS_DEST) {
+ __canvas_draw_invers(canvas, draw_method, data);
+ }
+
+ if (canvas_set_ropd_operator(cairo, rop_decriptor)) {
+ ASSERT(pattern);
+ cairo_set_source(cairo, pattern);
+ draw_method(data);
+ }
+
+ if (rop_decriptor & ROPD_INVERS_RES) {
+ __canvas_draw_invers(canvas, draw_method, data);
+ }
+ }
+}
+
+static inline void canvas_draw(CairoCanvas *canvas, Brush *brush, uint16_t rop_decriptor,
+ DrawMethod draw_method, void *data)
+{
+ cairo_pattern_t *pattern = canvas_get_brush(canvas, brush, rop_decriptor & ROPD_INVERS_BRUSH);
+ canvas_draw_with_pattern(canvas, pattern, rop_decriptor, draw_method, data);
+ if (pattern) {
+ cairo_pattern_destroy(pattern);
+ }
+}
+
+static cairo_pattern_t *canvas_get_mask_pattern(CairoCanvas *canvas, QMask *mask, int x, int y)
+{
+ cairo_surface_t *surface;
+ cairo_pattern_t *pattern;
+ cairo_matrix_t matrix;
+
+ if (!(surface = canvas_get_mask(&canvas->base, mask))) {
+ return NULL;
+ }
+ pattern = cairo_pattern_create_for_surface(surface);
+ if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+ cairo_surface_destroy(surface);
+ CANVAS_ERROR("create pattern failed, %s",
+ cairo_status_to_string(cairo_pattern_status(pattern)));
+ }
+ cairo_surface_destroy(surface);
+
+ cairo_matrix_init_translate(&matrix, mask->pos.x - x, mask->pos.y - y);
+ cairo_pattern_set_matrix(pattern, &matrix);
+ return pattern;
+}
+
+typedef struct DrawMaskData {
+ cairo_t *cairo;
+ cairo_pattern_t *mask;
+} DrawMaskData;
+
+static void __draw_mask(void *data)
+{
+ cairo_mask(((DrawMaskData *)data)->cairo, ((DrawMaskData *)data)->mask);
+}
+
+void canvas_draw_fill(CairoCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+{
+ DrawMaskData draw_data;
+ draw_data.cairo = canvas->cairo;
+
+ cairo_save(draw_data.cairo);
+ canvas_clip(canvas, clip);
+ if ((draw_data.mask = canvas_get_mask_pattern(canvas, &fill->mask, bbox->left, bbox->top))) {
+ cairo_rectangle(draw_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(draw_data.cairo);
+ canvas_draw(canvas, &fill->brush, fill->rop_decriptor, __draw_mask, &draw_data);
+ cairo_pattern_destroy(draw_data.mask);
+ } else {
+ cairo_rectangle(draw_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ canvas_draw(canvas, &fill->brush, fill->rop_decriptor, (DrawMethod)cairo_fill_preserve,
+ draw_data.cairo);
+ cairo_new_path(draw_data.cairo);
+ }
+ cairo_restore(draw_data.cairo);
+}
+
+static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, ADDRESS src_bitmap,
+ const Rect *src, const Rect *dest, int invers,
+ int scale_mode)
+{
+ cairo_pattern_t *pattern;
+ cairo_surface_t *surface;
+ cairo_matrix_t matrix;
+
+ ASSERT(src_bitmap);
+ ASSERT(scale_mode == IMAGE_SCALE_INTERPOLATE || scale_mode == IMAGE_SCALE_NEAREST);
+ if (invers) {
+ surface = canvas_get_invers_image(canvas, src_bitmap);
+ } else {
+ surface = canvas_get_image(&canvas->base, src_bitmap);
+ }
+
+ pattern = cairo_pattern_create_for_surface(surface);
+ cairo_surface_destroy(surface);
+ if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+ CANVAS_ERROR("create pattern failed, %s",
+ cairo_status_to_string(cairo_pattern_status(pattern)));
+ }
+
+ if (!rect_is_same_size(src, dest)) {
+ double sx, sy;
+
+ sx = (double)(src->right - src->left) / (dest->right - dest->left);
+ sy = (double)(src->bottom - src->top) / (dest->bottom - dest->top);
+
+ cairo_matrix_init_scale(&matrix, sx, sy);
+ cairo_pattern_set_filter(pattern, (scale_mode == IMAGE_SCALE_NEAREST) ?
+ CAIRO_FILTER_NEAREST : CAIRO_FILTER_GOOD);
+
+ cairo_matrix_translate(&matrix, src->left / sx - dest->left, src->top / sy - dest->top);
+ } else {
+ cairo_matrix_init_translate(&matrix, src->left - dest->left, src->top - dest->top);
+ }
+
+ cairo_pattern_set_matrix(pattern, &matrix);
+ return pattern;
+}
+
+void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_pattern_t *pattern;
+ cairo_pattern_t *mask;
+
+ cairo_save(cairo);
+ canvas_clip(canvas, clip);
+
+ pattern = canvas_src_image_to_pat(canvas, copy->src_bitmap, &copy->src_area, bbox,
+ copy->rop_decriptor & ROPD_INVERS_SRC, copy->scale_mode);
+ cairo_set_source(cairo, pattern);
+ cairo_pattern_destroy(pattern);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+ if ((mask = canvas_get_mask_pattern(canvas, &copy->mask, bbox->left, bbox->top))) {
+ cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(cairo);
+ cairo_mask(cairo, mask);
+ cairo_pattern_destroy(mask);
+ } else {
+ cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_fill(cairo);
+ }
+
+ cairo_restore(cairo);
+}
+
+#ifdef WIN32
+void canvas_put_image(CairoCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *_src_data,
+ uint32_t src_width, uint32_t src_height, int src_stride,
+ const QRegion *clip)
+#else
+void canvas_put_image(CairoCanvas *canvas, const Rect *dest, const uint8_t *_src_data,
+ uint32_t src_width, uint32_t src_height, int src_stride,
+ const QRegion *clip)
+#endif
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_surface_t* surf = NULL;
+ int dest_width;
+ int dest_height;
+ uint8_t *src_data = (uint8_t *)_src_data;
+ uint32_t *data;
+ int nstride;
+
+ cairo_save(cairo);
+
+ if (clip) {
+ const Rect *now = clip->rects;
+ const Rect *end = clip->rects + clip->num_rects;
+ for (; now < end; now++) {
+ cairo_rectangle(cairo, now->left, now->top, now->right - now->left,
+ now->bottom - now->top);
+ }
+ cairo_clip(cairo);
+ }
+
+
+ dest_width = dest->right - dest->left;
+ dest_height = dest->bottom - dest->top;
+
+ if (dest_width != src_width || dest_height != src_height) {
+ int x, y;
+ int x_mul = (uint32_t)((src_width << 16) / dest_width);
+ int y_mul = (uint32_t)((src_height << 16) / dest_height);
+ int new_y;
+ int set_y;
+ int nsrc_stride;
+
+ if (src_stride < 0) {
+ nsrc_stride = -src_stride;
+ src_data = src_data - (src_height - 1) * nsrc_stride;
+ nsrc_stride = nsrc_stride / 4;
+ } else {
+ nsrc_stride = src_stride / 4;
+ }
+ if ((dest_width * dest_height) > canvas->private_data_size) {
+ if (canvas->private_data) {
+ free(canvas->private_data);
+ canvas->private_data = NULL;
+ canvas->private_data_size = 0;
+ }
+ canvas->private_data = (uint32_t *)malloc(4 * dest_width * dest_height);
+ if (!canvas->private_data) {
+ return;
+ }
+ canvas->private_data_size = dest_width * dest_height;
+ }
+ if (!clip) {
+ surf = cairo_get_target(cairo);
+ data = (uint32_t *)cairo_image_surface_get_data(surf);
+ nstride = cairo_image_surface_get_stride(surf) / 4;
+ data += dest->top * nstride + dest->left + (dest_height - 1) * nstride;
+ } else {
+ data = (uint32_t *)canvas->private_data;
+ nstride = dest_width;
+ data += (dest_height - 1) * nstride;
+ }
+
+ for (y = 0; y < dest_height; ++y) {
+ int y_mul_stride = -y * nstride;
+ new_y = ((y * y_mul) >> 16);
+ set_y = (new_y * nsrc_stride);
+ for (x = 0; x < dest_width; ++x) {
+ data[y_mul_stride + x] = ((uint32_t *)src_data)[set_y + ((x * x_mul) >> 16)];
+ }
+ }
+ if (clip) {
+ surf = cairo_image_surface_create_for_data((uint8_t *)canvas->private_data,
+ CAIRO_FORMAT_RGB24, dest_width,
+ dest_height, 4 * dest_width);
+ }
+ } else {
+ surf = cairo_image_surface_create_for_data((uint8_t *)src_data, CAIRO_FORMAT_RGB24,
+ src_width, src_height, src_stride);
+ }
+
+ if (clip || !(dest_width != src_width || dest_height != src_height)) {
+ cairo_set_source_surface(cairo, surf, dest->left, dest->top);
+ cairo_surface_destroy(surf);
+
+ cairo_rectangle(cairo, dest->left, dest->top, dest_width, dest_height);
+ cairo_fill(cairo);
+ }
+ cairo_restore(cairo);
+}
+
+static cairo_surface_t *canvas_surf_to_color_maks_invers(cairo_surface_t *surface,
+ uint32_t trans_color)
+{
+ int width = cairo_image_surface_get_width(surface);
+ int height = cairo_image_surface_get_height(surface);
+ uint8_t *src_line;
+ uint8_t *end_src_line;
+ int src_stride;
+ uint8_t *dest_line;
+ int dest_stride;
+ cairo_surface_t *mask;
+ int i;
+
+ ASSERT(cairo_image_surface_get_format(surface) == CAIRO_FORMAT_ARGB32 ||
+ cairo_image_surface_get_format(surface) == CAIRO_FORMAT_RGB24);
+
+ mask = cairo_image_surface_create(CAIRO_FORMAT_A1, width, height);
+ if (cairo_surface_status(mask) != CAIRO_STATUS_SUCCESS) {
+ CANVAS_ERROR("create surface failed, %s",
+ cairo_status_to_string(cairo_surface_status(mask)));
+ }
+
+ src_line = cairo_image_surface_get_data(surface);
+ src_stride = cairo_image_surface_get_stride(surface);
+ end_src_line = src_line + src_stride * height;
+
+ dest_line = cairo_image_surface_get_data(mask);
+ dest_stride = cairo_image_surface_get_stride(mask);
+
+ for (; src_line != end_src_line; src_line += src_stride, dest_line += dest_stride) {
+ memset(dest_line, 0xff, dest_stride);
+ for (i = 0; i < width; i++) {
+ if ((((uint32_t*)src_line)[i] & 0x00ffffff) == trans_color) {
+ dest_line[i >> 3] &= ~(1 << (i & 0x07));
+ }
+ }
+ }
+
+ return mask;
+}
+
+void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transparent* transparent)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_pattern_t *pattern;
+ cairo_pattern_t *mask;
+ cairo_surface_t *surface;
+ cairo_surface_t *mask_surf;
+ cairo_matrix_t matrix;
+
+ cairo_save(cairo);
+ cairo_rectangle(cairo,
+ bbox->left,
+ bbox->top,
+ bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(cairo);
+ canvas_clip(canvas, clip);
+
+ pattern = canvas_src_image_to_pat(canvas, transparent->src_bitmap, &transparent->src_area, bbox,
+ 0, IMAGE_SCALE_NEAREST);
+ if (cairo_pattern_get_surface(pattern, &surface) != CAIRO_STATUS_SUCCESS) {
+ CANVAS_ERROR("surfase from pattern pattern failed");
+ }
+
+ mask_surf = canvas_surf_to_color_maks_invers(surface, transparent->true_color);
+ mask = cairo_pattern_create_for_surface(mask_surf);
+ cairo_surface_destroy(mask_surf);
+ if (cairo_pattern_status(mask) != CAIRO_STATUS_SUCCESS) {
+ CANVAS_ERROR("create pattern failed, %s",
+ cairo_status_to_string(cairo_pattern_status(pattern)));
+ }
+ cairo_pattern_get_matrix(pattern, &matrix);
+ cairo_pattern_set_matrix(mask, &matrix);
+
+ cairo_set_source(cairo, pattern);
+ cairo_pattern_destroy(pattern);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+ cairo_mask(cairo, mask);
+ cairo_pattern_destroy(mask);
+
+ cairo_restore(cairo);
+}
+
+void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_pattern_t *pattern;
+
+ cairo_save(cairo);
+ cairo_rectangle(cairo,
+ bbox->left,
+ bbox->top,
+ bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(cairo);
+ canvas_clip(canvas, clip);
+
+ pattern = canvas_src_image_to_pat(canvas, alpha_blend->src_bitmap, &alpha_blend->src_area, bbox,
+ 0, IMAGE_SCALE_INTERPOLATE);
+ cairo_set_source(cairo, pattern);
+ cairo_pattern_destroy(pattern);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_ATOP);
+ cairo_paint_with_alpha(cairo, (double)alpha_blend->alpha / 0xff);
+
+ cairo_restore(cairo);
+}
+
+void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+{
+ cairo_pattern_t *pattern;
+ DrawMaskData draw_data;
+
+ draw_data.cairo = canvas->cairo;
+
+ cairo_save(draw_data.cairo);
+ canvas_clip(canvas, clip);
+
+ pattern = canvas_src_image_to_pat(canvas, opaque->src_bitmap, &opaque->src_area, bbox,
+ opaque->rop_decriptor & ROPD_INVERS_SRC, opaque->scale_mode);
+ cairo_set_source(draw_data.cairo, pattern);
+ cairo_pattern_destroy(pattern);
+ cairo_set_operator(draw_data.cairo, CAIRO_OPERATOR_RASTER_COPY);
+ if ((draw_data.mask = canvas_get_mask_pattern(canvas, &opaque->mask, bbox->left, bbox->top))) {
+ cairo_rectangle(draw_data.cairo,
+ bbox->left,
+ bbox->top,
+ bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(draw_data.cairo);
+ cairo_mask(draw_data.cairo, draw_data.mask);
+ canvas_draw(canvas, &opaque->brush, opaque->rop_decriptor, __draw_mask, &draw_data);
+ cairo_pattern_destroy(draw_data.mask);
+ } else {
+ cairo_rectangle(draw_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_fill_preserve(draw_data.cairo);
+ canvas_draw(canvas, &opaque->brush, opaque->rop_decriptor, (DrawMethod)cairo_fill_preserve,
+ draw_data.cairo);
+ cairo_new_path(draw_data.cairo);
+ }
+
+ cairo_restore(draw_data.cairo);
+}
+
+void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+{
+ cairo_pattern_t *pattern;
+ DrawMaskData mask_data;
+
+ mask_data.cairo = canvas->cairo;
+
+ cairo_save(mask_data.cairo);
+ canvas_clip(canvas, clip);
+
+ pattern = canvas_src_image_to_pat(canvas, blend->src_bitmap, &blend->src_area, bbox,
+ blend->rop_decriptor & ROPD_INVERS_SRC, blend->scale_mode);
+
+ if ((mask_data.mask = canvas_get_mask_pattern(canvas, &blend->mask, bbox->left, bbox->top))) {
+ cairo_rectangle(mask_data.cairo,
+ bbox->left,
+ bbox->top,
+ bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(mask_data.cairo);
+ canvas_draw_with_pattern(canvas, pattern, blend->rop_decriptor, __draw_mask, &mask_data);
+ cairo_pattern_destroy(mask_data.mask);
+ } else {
+ cairo_rectangle(mask_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ canvas_draw_with_pattern(canvas, pattern, blend->rop_decriptor,
+ (DrawMethod)cairo_fill_preserve,
+ mask_data.cairo);
+ cairo_new_path(mask_data.cairo);
+ }
+ cairo_pattern_destroy(pattern);
+ cairo_restore(mask_data.cairo);
+}
+
+static inline void canvas_fill_common(CairoCanvas *canvas, Rect *bbox, Clip *clip,
+ QMask *qxl_mask)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_pattern_t *mask;
+
+ canvas_clip(canvas, clip);
+ if ((mask = canvas_get_mask_pattern(canvas, qxl_mask, bbox->left, bbox->top))) {
+ cairo_rectangle(cairo,
+ bbox->left,
+ bbox->top,
+ bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(cairo);
+ cairo_mask(cairo, mask);
+ cairo_pattern_destroy(mask);
+ } else {
+ cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_fill(cairo);
+ }
+}
+
+void canvas_draw_blackness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_save(cairo);
+ cairo_set_source_rgb(cairo, 0, 0, 0);
+ canvas_fill_common(canvas, bbox, clip, &blackness->mask);
+ cairo_restore(cairo);
+}
+
+void canvas_draw_whiteness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_save(cairo);
+ cairo_set_source_rgb(cairo, 1, 1, 1);
+ canvas_fill_common(canvas, bbox, clip, &whiteness->mask);
+ cairo_restore(cairo);
+}
+
+void canvas_draw_invers(CairoCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_save(cairo);
+ cairo_set_source_rgb(cairo, 1, 1, 1);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_XOR);
+ canvas_fill_common(canvas, bbox, clip, &invers->mask);
+ cairo_restore(cairo);
+}
+
+void canvas_draw_rop3(CairoCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_pattern_t *mask;
+ cairo_surface_t *d;
+ cairo_surface_t *s;
+ Point pos;
+ int width;
+ int heigth;
+ double x_pos;
+ double y_pos;
+ Point src_pos;
+
+ cairo_save(cairo);
+ canvas_clip(canvas, clip);
+ width = bbox->right - bbox->left;
+ heigth = bbox->bottom - bbox->top;
+ x_pos = bbox->left;
+ y_pos = bbox->top;
+ cairo_user_to_device(cairo, &x_pos, &y_pos);
+ pos.x = (INT32)x_pos;
+ pos.y = (INT32)y_pos;
+ d = canvas_surface_from_self(canvas, &pos, width, heigth);
+ s = canvas_get_image(&canvas->base, rop3->src_bitmap);
+
+ if (!rect_is_same_size(bbox, &rop3->src_area)) {
+ cairo_surface_t *scaled_s = canvas_scale_surface(s, &rop3->src_area, width, heigth,
+ rop3->scale_mode);
+ cairo_surface_destroy(s);
+ s = scaled_s;
+ src_pos.x = 0;
+ src_pos.y = 0;
+ } else {
+ src_pos.x = rop3->src_area.left;
+ src_pos.y = rop3->src_area.top;
+ }
+ if (cairo_image_surface_get_width(s) - src_pos.x < width ||
+ cairo_image_surface_get_height(s) - src_pos.y < heigth) {
+ CANVAS_ERROR("bad src bitmap size");
+ }
+ if (rop3->brush.type == BRUSH_TYPE_PATTERN) {
+ cairo_surface_t *p = canvas_get_image(&canvas->base, rop3->brush.u.pattern.pat);
+ Point pat_pos;
+
+ pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % cairo_image_surface_get_width(p);
+ pat_pos.y = (bbox->top - rop3->brush.u.pattern.pos.y) % cairo_image_surface_get_height(p);
+ do_rop3_with_pattern(rop3->rop3, d, s, &src_pos, p, &pat_pos);
+ cairo_surface_destroy(p);
+ } else {
+ uint32_t color = (canvas->base.color_shift) == 8 ? rop3->brush.u.color :
+ canvas_16bpp_to_32bpp(rop3->brush.u.color);
+ do_rop3_with_color(rop3->rop3, d, s, &src_pos, color);
+ }
+ cairo_surface_destroy(s);
+ cairo_set_source_surface(cairo, d, bbox->left, bbox->top);
+ cairo_surface_destroy(d);
+ if ((mask = canvas_get_mask_pattern(canvas, &rop3->mask, bbox->left, bbox->top))) {
+ cairo_rectangle(cairo,
+ bbox->left,
+ bbox->top,
+ bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_clip(cairo);
+ cairo_mask(cairo, mask);
+ cairo_pattern_destroy(mask);
+ } else {
+ cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+ bbox->bottom - bbox->top);
+ cairo_fill(cairo);
+ }
+ cairo_restore(cairo);
+}
+
+#define FAST_COPY_BITS
+
+#ifdef FAST_COPY_BITS
+
+static inline void __canvas_copy_bits_up(uint8_t *data, const int stride,
+ const int src_x, const int src_y,
+ const int width, const int height,
+ const int dest_x, const int dest_y)
+{
+ uint8_t *src = data + src_y * stride + src_x * sizeof(uint32_t);
+ uint8_t *dest = data + dest_y * stride + dest_x * sizeof(uint32_t);
+ uint8_t *end = dest + height * stride;
+ for (; dest != end; dest += stride, src += stride) {
+ memcpy(dest, src, width * sizeof(uint32_t));
+ }
+}
+
+static inline void __canvas_copy_bits_down(uint8_t *data, const int stride,
+ const int src_x, const int src_y,
+ const int width, const int height,
+ const int dest_x, const int dest_y)
+{
+ uint8_t *src = data + (src_y + height - 1) * stride + src_x * sizeof(uint32_t);
+ uint8_t *end = data + (dest_y - 1) * stride + dest_x * sizeof(uint32_t);
+ uint8_t *dest = end + height * stride;
+
+ for (; dest != end; dest -= stride, src -= stride) {
+ memcpy(dest, src, width * sizeof(uint32_t));
+ }
+}
+
+static inline void __canvas_copy_bits_right(uint8_t *data, const int stride,
+ const int src_x, const int src_y,
+ const int width, const int height,
+ const int dest_x, const int dest_y)
+{
+ uint8_t *src = data + src_y * stride + (src_x + width - 1) * sizeof(uint32_t);
+ uint8_t *dest = data + dest_y * stride + (dest_x + width - 1) * sizeof(uint32_t);
+ uint8_t *end = dest + height * stride;
+ for (; dest != end; dest += stride, src += stride) {
+ uint32_t *src_pix = (uint32_t *)src;
+ uint32_t *end_pix = src_pix - width;
+ uint32_t *dest_pix = (uint32_t *)dest;
+
+ for (; src_pix > end_pix; src_pix--, dest_pix--) {
+ *dest_pix = *src_pix;
+ }
+ }
+}
+
+static inline void __canvas_copy_rect_bits(uint8_t *data, const int stride, Rect *dest_rect,
+ Point *src_pos)
+{
+ if (dest_rect->top > src_pos->y) {
+ __canvas_copy_bits_down(data, stride, src_pos->x, src_pos->y,
+ dest_rect->right - dest_rect->left,
+ dest_rect->bottom - dest_rect->top,
+ dest_rect->left, dest_rect->top);
+ } else if (dest_rect->top < src_pos->y || dest_rect->left < src_pos->x) {
+ __canvas_copy_bits_up(data, stride, src_pos->x, src_pos->y,
+ dest_rect->right - dest_rect->left,
+ dest_rect->bottom - dest_rect->top,
+ dest_rect->left, dest_rect->top);
+ } else {
+ __canvas_copy_bits_right(data, stride, src_pos->x, src_pos->y,
+ dest_rect->right - dest_rect->left,
+ dest_rect->bottom - dest_rect->top,
+ dest_rect->left, dest_rect->top);
+ }
+}
+
+static inline void canvas_copy_fix_clip_area(const Rect *dest,
+ const Point *src_pos,
+ const Rect *now,
+ Point *ret_pos,
+ Rect *ret_dest)
+{
+ *ret_dest = *now;
+ rect_sect(ret_dest, dest);
+ ret_pos->x = src_pos->x + (ret_dest->left - dest->left);
+ ret_pos->y = src_pos->y + (ret_dest->top - dest->top);
+}
+
+static inline void __canvas_copy_region_bits(uint8_t *data, int stride, Rect *dest_rect,
+ Point *src_pos, QRegion *region)
+{
+ Rect curr_area;
+ Point curr_pos;
+ Rect *now;
+ Rect *end;
+
+ if (dest_rect->top > src_pos->y) {
+ end = region->rects - 1;
+ now = end + region->num_rects;
+ if (dest_rect->left < src_pos->x) {
+ for (; now > end; now--) {
+ Rect *line_end = now;
+ Rect *line_pos;
+
+ while (now - 1 > end && now->top == now[-1].top) {
+ now--;
+ }
+
+ for (line_pos = now; line_pos <= line_end; line_pos++) {
+ canvas_copy_fix_clip_area(dest_rect, src_pos, line_pos, &curr_pos, &curr_area);
+ __canvas_copy_bits_down(data, stride, curr_pos.x, curr_pos.y,
+ curr_area.right - curr_area.left,
+ curr_area.bottom - curr_area.top,
+ curr_area.left, curr_area.top);
+ }
+ }
+ } else {
+ for (; now > end; now--) {
+ canvas_copy_fix_clip_area(dest_rect, src_pos, now, &curr_pos, &curr_area);
+ __canvas_copy_bits_down(data, stride, curr_pos.x, curr_pos.y,
+ curr_area.right - curr_area.left,
+ curr_area.bottom - curr_area.top,
+ curr_area.left, curr_area.top);
+ }
+ }
+ } else if (dest_rect->top < src_pos->y || dest_rect->left < src_pos->x) {
+ now = region->rects;
+ end = now + region->num_rects;
+ if (dest_rect->left > src_pos->x) {
+ for (; now < end; now++) {
+ Rect *line_end = now;
+ Rect *line_pos;
+
+ while (now + 1 < end && now->top == now[1].top) {
+ now++;
+ }
+
+ for (line_pos = now; line_pos >= line_end; line_pos--) {
+ canvas_copy_fix_clip_area(dest_rect, src_pos, line_pos, &curr_pos, &curr_area);
+ __canvas_copy_bits_up(data, stride, curr_pos.x, curr_pos.y,
+ curr_area.right - curr_area.left,
+ curr_area.bottom - curr_area.top,
+ curr_area.left, curr_area.top);
+ }
+ }
+ } else {
+ for (; now < end; now++) {
+ canvas_copy_fix_clip_area(dest_rect, src_pos, now, &curr_pos, &curr_area);
+ __canvas_copy_bits_up(data, stride, curr_pos.x, curr_pos.y,
+ curr_area.right - curr_area.left,
+ curr_area.bottom - curr_area.top,
+ curr_area.left, curr_area.top);
+ }
+ }
+ } else {
+ end = region->rects - 1;
+ now = end + region->num_rects;
+ for (; now > end; now--) {
+ canvas_copy_fix_clip_area(dest_rect, src_pos, now, &curr_pos, &curr_area);
+ __canvas_copy_bits_right(data, stride, curr_pos.x, curr_pos.y,
+ curr_area.right - curr_area.left,
+ curr_area.bottom - curr_area.top,
+ curr_area.left, curr_area.top);
+ }
+ }
+}
+
+#endif
+
+void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_surface_t *surface;
+ int32_t width;
+ int32_t heigth;
+
+ cairo_save(cairo);
+#ifdef FAST_COPY_BITS
+ switch (clip->type) {
+ case CLIP_TYPE_NONE: {
+ surface = cairo_get_target(cairo);
+ __canvas_copy_rect_bits(cairo_image_surface_get_data(surface),
+ cairo_image_surface_get_stride(surface),
+ bbox, src_pos);
+ break;
+ }
+ case CLIP_TYPE_RECTS: {
+ surface = cairo_get_target(cairo);
+ uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+ access_test(&canvas->base, n, sizeof(uint32_t));
+
+ Rect *now = (Rect *)(n + 1);
+ Rect *end = now + *n;
+ access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
+ uint8_t *data = cairo_image_surface_get_data(surface);
+ int stride = cairo_image_surface_get_stride(surface);
+
+ //using QRegion in order to sort and remove intersections
+ QRegion region;
+ region_init(&region);
+ for (; now < end; now++) {
+ region_add(&region, now);
+ }
+ __canvas_copy_region_bits(data, stride, bbox, src_pos, &region);
+ region_destroy(&region);
+ break;
+ }
+ default:
+#endif
+ canvas_clip(canvas, clip);
+
+ width = bbox->right - bbox->left;
+ heigth = bbox->bottom - bbox->top;
+ surface = canvas_surface_from_self(canvas, src_pos, width, heigth);
+ cairo_set_source_surface(cairo, surface, bbox->left, bbox->top);
+ cairo_surface_destroy(surface);
+ cairo_rectangle(cairo, bbox->left, bbox->top, width, heigth);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+ cairo_fill(cairo);
+#ifdef FAST_COPY_BITS
+ }
+
+#endif
+ cairo_restore(cairo);
+}
+
+static void canvas_draw_raster_str(CairoCanvas *canvas, String *str, int bpp,
+ Brush *brush, uint16_t rop_decriptor)
+{
+ cairo_surface_t *str_mask;
+ DrawMaskData draw_data;
+ cairo_matrix_t matrix;
+ Point pos;
+
+ str_mask = canvas_get_str_mask(&canvas->base, str, bpp, &pos);
+ draw_data.cairo = canvas->cairo;
+ draw_data.mask = cairo_pattern_create_for_surface(str_mask);
+ if (cairo_pattern_status(draw_data.mask) != CAIRO_STATUS_SUCCESS) {
+ cairo_surface_destroy(str_mask);
+ CANVAS_ERROR("create pattern failed, %s",
+ cairo_status_to_string(cairo_pattern_status(draw_data.mask)));
+ }
+ cairo_matrix_init_translate(&matrix, -pos.x, -pos.y);
+ cairo_pattern_set_matrix(draw_data.mask, &matrix);
+ canvas_draw(canvas, brush, rop_decriptor, __draw_mask, &draw_data);
+ cairo_pattern_destroy(draw_data.mask);
+ cairo_surface_destroy(str_mask);
+}
+
+static void canvas_draw_vector_str(CairoCanvas *canvas, String *str, Brush *brush,
+ uint16_t rop_decriptor)
+{
+ VectotGlyph *glyph = (VectotGlyph *)str->data;
+ int i;
+
+ for (i = 0; i < str->length; i++) {
+ VectotGlyph *next_glyph = canvas_next_vector_glyph(glyph);
+ access_test(&canvas->base, glyph, (uint8_t *)next_glyph - (uint8_t *)glyph);
+ canvas_set_path(canvas, glyph->data);
+ glyph = next_glyph;
+ }
+ canvas_draw(canvas, brush, rop_decriptor, (DrawMethod)cairo_fill_preserve, canvas->cairo);
+ cairo_new_path(canvas->cairo);
+}
+
+void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+{
+ cairo_t *cairo = canvas->cairo;
+ String *str;
+
+ cairo_save(cairo);
+ canvas_clip(canvas, clip);
+ if (!rect_is_empty(&text->back_area)) {
+ cairo_rectangle(cairo,
+ text->back_area.left,
+ text->back_area.top,
+ text->back_area.right - text->back_area.left,
+ text->back_area.bottom - text->back_area.top);
+ canvas_draw(canvas, &text->back_brush, text->back_mode,
+ (DrawMethod)cairo_fill_preserve, cairo);
+ cairo_new_path(cairo);
+ }
+ str = (String *)GET_ADDRESS(text->str);
+
+ if (str->flags & STRING_RASTER_A1) {
+ canvas_draw_raster_str(canvas, str, 1, &text->fore_brush, text->fore_mode);
+ } else if (str->flags & STRING_RASTER_A4) {
+ canvas_draw_raster_str(canvas, str, 4, &text->fore_brush, text->fore_mode);
+ } else if (str->flags & STRING_RASTER_A8) {
+ WARN("untested path A8 glyphs, doing nothing");
+ if (0) {
+ canvas_draw_raster_str(canvas, str, 8, &text->fore_brush, text->fore_mode);
+ }
+ } else {
+ WARN("untested path vector glyphs, doing nothing");
+ if (0) {
+ canvas_draw_vector_str(canvas, str, &text->fore_brush, text->fore_mode);
+ }
+ }
+ cairo_restore(cairo);
+}
+
+void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+{
+ cairo_t *cairo = canvas->cairo;
+
+ cairo_save(cairo);
+ canvas_clip(canvas, clip);
+
+ canvas_set_line_attr_no_dash(canvas, &stroke->attr);
+ canvas_set_path(canvas, GET_ADDRESS(stroke->path));
+ if (stroke->attr.flags & LINE_ATTR_STYLED) {
+ canvas_draw(canvas, &stroke->brush, stroke->back_mode,
+ (DrawMethod)cairo_stroke_preserve, cairo);
+ canvas_set_dash(canvas, stroke->attr.style_nseg, stroke->attr.style,
+ !!(stroke->attr.flags & LINE_ATTR_STARTGAP));
+ }
+ canvas_draw(canvas, &stroke->brush, stroke->fore_mode, (DrawMethod)cairo_stroke_preserve,
+ cairo);
+ cairo_new_path(cairo);
+ cairo_restore(cairo);
+}
+
+void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area)
+{
+ cairo_t *cairo = canvas->cairo;
+ cairo_surface_t* surface;
+ uint8_t *src;
+ int src_stride;
+ uint8_t *dest_end;
+
+ ASSERT(canvas && area);
+
+ surface = cairo_get_target(cairo);
+ src_stride = cairo_image_surface_get_stride(surface);
+ src = cairo_image_surface_get_data(surface) + area->top * src_stride +
+ area->left * sizeof(uint32_t);
+ dest_end = dest + (area->bottom - area->top) * dest_stride;
+ for (; dest != dest_end; dest += dest_stride, src += src_stride) {
+ memcpy(dest, src, dest_stride);
+ }
+}
+
+void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, Rect *clip_rects)
+{
+ cairo_t *cairo = canvas->cairo;
+
+ cairo_save(cairo);
+
+ if (n_clip_rects) {
+ Rect *end = clip_rects + n_clip_rects;
+ for (; clip_rects < end; clip_rects++) {
+ cairo_rectangle(cairo,
+ clip_rects->left,
+ clip_rects->top,
+ clip_rects->right - clip_rects->left,
+ clip_rects->bottom - clip_rects->top);
+ }
+ cairo_clip(cairo);
+ }
+}
+
+void canvas_group_end(CairoCanvas *canvas)
+{
+ cairo_restore(canvas->cairo);
+}
+
+void canvas_clear(CairoCanvas *canvas)
+{
+ cairo_t *cairo = canvas->cairo;
+
+ ASSERT(cairo);
+ cairo_save(cairo);
+ cairo_reset_clip(cairo);
+ cairo_set_operator(cairo, CAIRO_OPERATOR_CLEAR);
+ cairo_paint(cairo);
+ cairo_restore(cairo);
+}
+
+cairo_t *canvas_get_cairo(CairoCanvas *canvas)
+{
+ return canvas->cairo;
+}
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void canvas_set_access_params(CairoCanvas *canvas, ADDRESS delta, unsigned long base,
+ unsigned long max)
+{
+ __canvas_set_access_params(&canvas->base, delta, base, max);
+}
+
+#else
+void canvas_set_access_params(CairoCanvas *canvas, ADDRESS delta)
+{
+ __canvas_set_access_params(&canvas->base, delta);
+}
+
+#endif
+
+void canvas_destroy(CairoCanvas *canvas)
+{
+ if (!canvas) {
+ return;
+ }
+ canvas_base_destroy(&canvas->base);
+ if (canvas->private_data) {
+ free(canvas->private_data);
+ }
+ free(canvas);
+}
+
+static int need_init = 1;
+
+#ifdef CAIRO_CANVAS_CACHE
+CairoCanvas *canvas_create(cairo_t *cairo, int bits,
+ void *bits_cache_opaque,
+ bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get,
+ void *palette_cache_opaque, palette_cache_put_fn_t palette_cache_put,
+ palette_cache_get_fn_t palette_cache_get,
+ palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+CairoCanvas *canvas_create(cairo_t *cairo, int bits,
+ void *bits_cache_opaque,
+ bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get
+#else
+CairoCanvas *canvas_create(cairo_t *cairo, int bits
+#endif
+#ifdef USE_GLZ
+ , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+ )
+{
+ CairoCanvas *canvas;
+ int init_ok;
+
+ if (need_init || !(canvas = (CairoCanvas *)malloc(sizeof(CairoCanvas)))) {
+ return NULL;
+ }
+ memset(canvas, 0, sizeof(CairoCanvas));
+#ifdef CAIRO_CANVAS_CACHE
+ init_ok = canvas_base_init(&canvas->base, bits,
+ bits_cache_opaque,
+ bits_cache_put,
+ bits_cache_get,
+ palette_cache_opaque,
+ palette_cache_put,
+ palette_cache_get,
+ palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+ init_ok = canvas_base_init(&canvas->base, bits,
+ bits_cache_opaque,
+ bits_cache_put,
+ bits_cache_get
+#else
+ init_ok = canvas_base_init(&canvas->base, bits
+#endif
+#ifdef USE_GLZ
+ ,
+ glz_decoder_opaque,
+ glz_decode
+#endif
+ );
+ canvas->cairo = cairo;
+ canvas->private_data = NULL;
+ canvas->private_data_size = 0;
+ cairo_set_antialias(cairo, CAIRO_ANTIALIAS_NONE);
+ return canvas;
+}
+
+void cairo_canvas_init() //unsafe global function
+{
+ if (!need_init) {
+ return;
+ }
+ need_init = 0;
+ rop3_init();
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-18 17:03:32 +0000