pxcloud/spice-common
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice-common synced 2025-12-27 15:08:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
89d886bdcb
spice-common/canvas_base.c
Izik Eidus 777f7ad806 spice: server: add memslots support. 
Signed-off-by: Izik Eidus <ieidus@redhat.com>
2009-11-23 20:54:11 +02:00

1626 lines
47 KiB
C
Raw Blame History

/*
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 <stdarg.h>
#include <cairo.h>
#include <stdlib.h>
#include <setjmp.h>
#include <stdio.h>
#include "draw.h"
#include "quic.h"
#include "lz.h"
#include "canvas_base.h"
#include "canvas_utils.h"
#include "rect.h"
#include "mutex.h"
#ifndef CANVAS_ERROR
#define CANVAS_ERROR(format, ...) { \
printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__); \
abort(); \
}
#endif
#ifdef CAIRO_CANVAS_ACCESS_TEST
#define access_test(cancas, ptr, size) \
if ((unsigned long)(ptr) < (cancas)->base || \
(unsigned long)(ptr) + (size) > (cancas)->max) { \
CANVAS_ERROR("access violation 0x%lx %lu", (unsigned long)ptr, (unsigned long)(size)); \
}
#else
#define access_test(cancas, base, size)
#endif
#ifndef ASSERT
#define ASSERT(x) if (!(x)) { \
printf("%s: ASSERT %s failed\n", __FUNCTION__, #x); \
abort(); \
}
#endif
#ifndef WARN
#define WARN(x) printf("warning: %s\n", x)
#endif
#ifndef DBG
#define DBG(level, format, ...) printf("%s: debug: " format "\n", __FUNCTION__, ## __VA_ARGS__);
#endif
#ifndef ALIGN
#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
#endif
#ifndef MIN
#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
#endif
#ifndef MAX
#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
#endif
#ifdef WIN32
typedef struct __declspec (align(1)) LZImage {
#else
typedef struct __attribute__ ((__packed__)) LZImage {
#endif
ImageDescriptor descriptor;
union {
LZ_RGBData lz_rgb;
LZ_PLTData lz_plt;
};
} LZImage;
static const cairo_user_data_key_t invers_data_type = {0};
#ifdef CAIRO_CANVAS_CACH_IS_SHARED
/* should be defined and initialized once in application.cpp */
extern mutex_t cairo_surface_user_data_mutex;
#endif
static inline double fix_to_double(FIXED28_4 fixed)
{
return (double)(fixed & 0x0f) / 0x0f + (fixed >> 4);
}
static inline uint32_t canvas_16bpp_to_32bpp(uint32_t color)
{
uint32_t ret;
ret = ((color & 0x001f) << 3) | ((color & 0x001c) >> 2);
ret |= ((color & 0x03e0) << 6) | ((color & 0x0380) << 1);
ret |= ((color & 0x7c00) << 9) | ((color & 0x7000) << 4);
return ret;
}
static inline int test_bit(void* addr, int bit)
{
return !!(((uint32_t*)addr)[bit >> 5] & (1 << (bit & 0x1f)));
}
static inline int test_bit_be(void* addr, int bit)
{
return !!(((uint8_t*)addr)[bit >> 3] & (0x80 >> (bit & 0x07)));
}
#ifdef WIN32
static HDC create_compatible_dc()
{
HDC dc = CreateCompatibleDC(NULL);
if (!dc) {
CANVAS_ERROR("create compatible DC failed");
}
return dc;
}
#endif
typedef struct LzData {
LzUsrContext usr;
LzContext *lz;
LzDecodeUsrData decode_data;
jmp_buf jmp_env;
char message_buf[512];
} LzData;
typedef struct GlzData {
void *decoder_opaque;
glz_decode_fn_t decode;
LzDecodeUsrData decode_data;
} GlzData;
typedef struct QuicData {
QuicUsrContext usr;
QuicContext *quic;
jmp_buf jmp_env;
#ifndef CAIRO_CANVAS_NO_CHUNKS
ADDRESS next;
get_virt_fn_t get_virt;
void *get_virt_opaque;
validate_virt_fn_t validate_virt;
void *validate_virt_opaque;
#endif
char message_buf[512];
} QuicData;
typedef struct CanvasBase {
uint32_t color_shift;
uint32_t color_mask;
QuicData quic_data;
#ifdef CAIRO_CANVAS_ACCESS_TEST
unsigned long base;
unsigned long max;
#endif
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
void *bits_cache_opaque;
bits_cache_put_fn_t bits_cache_put;
bits_cache_get_fn_t bits_cache_get;
#endif
#ifdef CAIRO_CANVAS_CACHE
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;
#endif
#ifdef WIN32
HDC dc;
#endif
LzData lz_data;
GlzData glz_data;
} CanvasBase;
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifdef __GNUC__
#define ATTR_PACKED __attribute__ ((__packed__))
#else
#pragma pack(push)
#pragma pack(1)
#define ATTR_PACKED
#endif
typedef struct ATTR_PACKED DataChunk {
UINT32 size;
ADDRESS prev;
ADDRESS next;
UINT8 data[0];
} DataChunk;
#undef ATTR_PACKED
#ifndef __GNUC__
#pragma pack(pop)
#endif
#endif
static inline void canvas_localize_palette(CanvasBase *canvas, Palette *palette)
{
if (canvas->color_shift == 5) {
UINT32 *now = palette->ents;
UINT32 *end = now + palette->num_ents;
for (; now < end; now++) {
*now = canvas_16bpp_to_32bpp(*now);
}
}
}
//#define DEBUG_DUMP_COMPRESS
#ifdef DEBUG_DUMP_COMPRESS
static void dump_surface(cairo_surface_t *surface, int cache);
#endif
static cairo_surface_t *canvas_get_quic(CanvasBase *canvas, QUICImage *image, int invers)
{
cairo_surface_t *surface = NULL;
QuicData *quic_data = &canvas->quic_data;
QuicImageType type;
uint8_t *dest;
int stride;
int width;
int height;
int alpha;
#ifndef CAIRO_CANVAS_NO_CHUNKS
DataChunk **tmp;
DataChunk *chunk;
#endif
if (setjmp(quic_data->jmp_env)) {
cairo_surface_destroy(surface);
CANVAS_ERROR("quic error, %s", quic_data->message_buf);
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
if (quic_decode_begin(quic_data->quic, (uint32_t *)image->quic.data,
image->quic.data_size >> 2, &type, &width, &height) == QUIC_ERROR) {
CANVAS_ERROR("quic decode begin failed");
}
#else
tmp = (DataChunk **)image->quic.data;
chunk = *tmp;
quic_data->next = chunk->next;
if (quic_decode_begin(quic_data->quic, (uint32_t *)chunk->data, chunk->size >> 2,
&type, &width, &height) == QUIC_ERROR) {
CANVAS_ERROR("quic decode begin failed");
}
#endif
switch (type) {
case QUIC_IMAGE_TYPE_RGBA:
alpha = 1;
break;
case QUIC_IMAGE_TYPE_RGB32:
case QUIC_IMAGE_TYPE_RGB24:
case QUIC_IMAGE_TYPE_RGB16:
alpha = 0;
break;
case QUIC_IMAGE_TYPE_INVALID:
case QUIC_IMAGE_TYPE_GRAY:
default:
CANVAS_ERROR("unexpected image type");
}
ASSERT((uint32_t)width == image->descriptor.width);
ASSERT((uint32_t)height == image->descriptor.height);
surface = surface_create(
#ifdef WIN32
canvas->dc,
#endif
alpha ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
width, height, FALSE);
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);
stride = cairo_image_surface_get_stride(surface);
if (quic_decode(quic_data->quic, alpha ? QUIC_IMAGE_TYPE_RGBA : QUIC_IMAGE_TYPE_RGB32,
dest, stride) == QUIC_ERROR) {
CANVAS_ERROR("quic decode failed");
}
if (invers) {
uint8_t *end = dest + height * stride;
for (; dest != end; dest += stride) {
uint32_t *pix;
uint32_t *end_pix;
pix = (uint32_t *)dest;
end_pix = pix + width;
for (; pix < end_pix; pix++) {
*pix ^= 0x00ffffff;
}
}
}
#ifdef DEBUG_DUMP_COMPRESS
dump_surface(surface, 0);
#endif
return surface;
}
static inline void canvas_copy_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) {
memcpy(dest, src, width << 2);
}
}
static inline void canvas_copy_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_copy_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);
}
}
}
static inline void canvas_copy_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++)];
}
}
}
static inline void canvas_copy_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];
*(dest_line++) = palette->ents[*(now++) & 0x0f];
}
if (width & 1) {
*(dest_line) = palette->ents[(*src >> 4) & 0x0f];
}
}
}
static inline void canvas_copy_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;
} else {
*(dest_line++) = back_color;
}
}
}
}
static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *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, src, bitmap->y * src_stride);
cairo_surface = surface_create(
#ifdef WIN32
canvas->dc,
#endif
(bitmap->format == BITMAP_FMT_RGBA) ? CAIRO_FORMAT_ARGB32 :
CAIRO_FORMAT_RGB24,
bitmap->x, bitmap->y, FALSE);
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 * ((int)bitmap->y - 1);
dest_stride = -dest_stride;
}
switch (bitmap->format) {
case BITMAP_FMT_32BIT:
case BITMAP_FMT_RGBA:
canvas_copy_32bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
break;
case BITMAP_FMT_24BIT:
canvas_copy_24bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
break;
case BITMAP_FMT_16BIT:
canvas_copy_16bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
break;
case BITMAP_FMT_8BIT:
canvas_copy_8bpp(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
break;
case BITMAP_FMT_4BIT_BE:
canvas_copy_4bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
break;
case BITMAP_FMT_1BIT_BE:
canvas_copy_1bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
break;
}
return cairo_surface;
}
#ifdef CAIRO_CANVAS_CACHE
static inline Palette *canvas_get_palett(CanvasBase *canvas, ADDRESS base_palette, uint8_t flags)
{
Palette *palette;
if (!base_palette) {
return NULL;
}
if (flags & BITMAP_PAL_FROM_CACHE) {
palette = canvas->palette_cache_get(canvas->palette_cache_opaque, base_palette);
} else if (flags & BITMAP_PAL_CACHE_ME) {
palette = (Palette *)GET_ADDRESS(base_palette);
access_test(canvas, palette, sizeof(Palette));
access_test(canvas, palette, sizeof(Palette) + palette->num_ents * sizeof(uint32_t));
canvas_localize_palette(canvas, palette);
canvas->palette_cache_put(canvas->palette_cache_opaque, palette);
} else {
palette = (Palette *)GET_ADDRESS(base_palette);
canvas_localize_palette(canvas, palette);
}
return palette;
}
static cairo_surface_t *canvas_get_lz(CanvasBase *canvas, LZImage *image, int invers)
{
LzData *lz_data = &canvas->lz_data;
uint8_t *comp_buf = NULL;
int comp_size;
uint8_t *decomp_buf = NULL;
uint8_t *src;
LzImageType type;
Palette *palette;
int alpha;
int n_comp_pixels;
int width;
int height;
int top_down;
int stride;
if (setjmp(lz_data->jmp_env)) {
if (decomp_buf) {
free(decomp_buf);
}
CANVAS_ERROR("lz error, %s", lz_data->message_buf);
}
if (image->descriptor.type == IMAGE_TYPE_LZ_RGB) {
comp_buf = image->lz_rgb.data;
comp_size = image->lz_rgb.data_size;
palette = NULL;
} else if (image->descriptor.type == IMAGE_TYPE_LZ_PLT) {
comp_buf = image->lz_plt.data;
comp_size = image->lz_plt.data_size;
palette = canvas_get_palett(canvas, image->lz_plt.palette, image->lz_plt.flags);
} else {
CANVAS_ERROR("unexpected image type");
}
lz_decode_begin(lz_data->lz, comp_buf, comp_size, &type,
&width, &height, &n_comp_pixels, &top_down, palette);
switch (type) {
case LZ_IMAGE_TYPE_RGBA:
alpha = 1;
break;
case LZ_IMAGE_TYPE_RGB32:
case LZ_IMAGE_TYPE_RGB24:
case LZ_IMAGE_TYPE_RGB16:
case LZ_IMAGE_TYPE_PLT1_LE:
case LZ_IMAGE_TYPE_PLT1_BE:
case LZ_IMAGE_TYPE_PLT4_LE:
case LZ_IMAGE_TYPE_PLT4_BE:
case LZ_IMAGE_TYPE_PLT8:
alpha = 0;
break;
default:
CANVAS_ERROR("unexpected LZ image type");
}
ASSERT(width == image->descriptor.width);
ASSERT(height == image->descriptor.height);
ASSERT((image->descriptor.type == IMAGE_TYPE_LZ_PLT) || (n_comp_pixels == width * height));
#ifdef WIN32
lz_data->decode_data.dc = canvas->dc;
#endif
alloc_lz_image_surface(&lz_data->decode_data, alpha ? LZ_IMAGE_TYPE_RGBA : LZ_IMAGE_TYPE_RGB32,
width, height, n_comp_pixels, top_down);
src = cairo_image_surface_get_data(lz_data->decode_data.out_surface);
stride = (n_comp_pixels / height) * 4;
if (!top_down) {
stride = -stride;
decomp_buf = src + stride * (height - 1);
} else {
decomp_buf = src;
}
lz_decode(lz_data->lz, alpha ? LZ_IMAGE_TYPE_RGBA : LZ_IMAGE_TYPE_RGB32, decomp_buf);
if (invers) {
uint8_t *line = src;
uint8_t *end = src + height * stride;
for (; line != end; line += stride) {
uint32_t *pix;
uint32_t *end_pix;
pix = (uint32_t *)line;
end_pix = pix + width;
for (; pix < end_pix; pix++) {
*pix ^= 0x00ffffff;
}
}
}
return lz_data->decode_data.out_surface;
}
// don't handle plts since bitmaps with plt can be decoded globaly to RGB32 (because
// same byte sequence can be transformed to different RGB pixels by different plts)
static cairo_surface_t *canvas_get_glz(CanvasBase *canvas, LZImage *image)
{
ASSERT(image->descriptor.type == IMAGE_TYPE_GLZ_RGB);
#ifdef WIN32
canvas->glz_data.decode_data.dc = canvas->dc;
#endif
canvas->glz_data.decode(canvas->glz_data.decoder_opaque, image->lz_rgb.data, NULL,
&canvas->glz_data.decode_data);
/* global_decode calls alloc_lz_image, which sets canvas->glz_data.surface */
return (canvas->glz_data.decode_data.out_surface);
}
//#define DEBUG_DUMP_BITMAP
#ifdef DEBUG_DUMP_BITMAP
static void dump_bitmap(Bitmap *bitmap, Palette *palette)
{
uint8_t* data = (uint8_t *)GET_ADDRESS(bitmap->data);
static uint32_t file_id = 0;
uint32_t i, j;
char file_str[200];
uint32_t id = ++file_id;
#ifdef WIN32
sprintf(file_str, "c:\\tmp\\spice_dump\\%u.%ubpp", id, bitmap->format);
#else
sprintf(file_str, "/tmp/spice_dump/%u.%ubpp", id, bitmap->format);
#endif
FILE *f = fopen(file_str, "wb");
if (!f) {
return;
}
fprintf(f, "%d\n", bitmap->format); // 1_LE,1_BE,....
fprintf(f, "%d %d\n", bitmap->x, bitmap->y); // width and height
fprintf(f, "%d\n", palette->num_ents); // #plt entries
for (i = 0; i < palette->num_ents; i++) {
fwrite(&(palette->ents[i]), 4, 1, f);
}
fprintf(f, "\n");
for (i = 0; i < bitmap->y; i++, data += bitmap->stride) {
uint8_t *now = data;
for (j = 0; j < bitmap->x; j++) {
fwrite(now, 1, 1, f);
now++;
}
}
}
#endif
static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
{
cairo_surface_t* surface;
Palette *palette;
palette = canvas_get_palett(canvas, bitmap->palette, bitmap->flags);
#ifdef DEBUG_DUMP_BITMAP
if (palette) {
dump_bitmap(bitmap, palette);
}
#endif
surface = canvas_bitmap_to_surface(canvas, bitmap, palette);
if (palette && (bitmap->flags & BITMAP_PAL_FROM_CACHE)) {
canvas->palette_cache_release(palette);
}
return surface;
}
#else
static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
{
Palette *palette;
if (!bitmap->palette) {
return canvas_bitmap_to_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, local_palette);
surface = canvas_bitmap_to_surface(canvas, bitmap, local_palette);
free(local_palette);
return surface;
} else {
return canvas_bitmap_to_surface(canvas, bitmap, palette);
}
}
#endif
// caution: defining DEBUG_DUMP_SURFACE will dump both cached & non-cached
// images to disk. it will reduce performance dramatically & eat
// disk space rapidly. use it only for debugging.
//#define DEBUG_DUMP_SURFACE
#if defined(DEBUG_DUMP_SURFACE) || defined(DEBUG_DUMP_COMPRESS)
static void dump_surface(cairo_surface_t *surface, int cache)
{
static uint32_t file_id = 0;
int i, j;
char file_str[200];
cairo_format_t format = cairo_image_surface_get_format(surface);
if (format != CAIRO_FORMAT_RGB24 && format != CAIRO_FORMAT_ARGB32) {
return;
}
uint8_t *data = cairo_image_surface_get_data(surface);
int width = cairo_image_surface_get_width(surface);
int height = cairo_image_surface_get_height(surface);
int stride = cairo_image_surface_get_stride(surface);
uint32_t id = ++file_id;
#ifdef WIN32
sprintf(file_str, "c:\\tmp\\spice_dump\\%d\\%u.ppm", cache, id);
#else
sprintf(file_str, "/tmp/spice_dump/%u.ppm", id);
#endif
FILE *f = fopen(file_str, "wb");
if (!f) {
return;
}
fprintf(f, "P6\n");
fprintf(f, "%d %d\n", width, height);
fprintf(f, "#spicec dump\n");
fprintf(f, "255\n");
for (i = 0; i < height; i++, data += stride) {
uint8_t *now = data;
for (j = 0; j < width; j++) {
fwrite(&now[2], 1, 1, f);
fwrite(&now[1], 1, 1, f);
fwrite(&now[0], 1, 1, f);
now += 4;
}
}
fclose(f);
}
#endif
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
static void __release_surface(void *inv_surf)
{
cairo_surface_destroy((cairo_surface_t *)inv_surf);
}
//#define DEBUG_LZ
static cairo_surface_t *canvas_get_image(CanvasBase *canvas, ADDRESS addr)
{
ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
cairo_surface_t *surface;
access_test(canvas, descriptor, sizeof(ImageDescriptor));
#ifdef DEBUG_LZ
LOG_DEBUG("canvas_get_image image type: " << (int)descriptor->type);
#endif
switch (descriptor->type) {
case IMAGE_TYPE_QUIC: {
QUICImage *image = (QUICImage *)descriptor;
access_test(canvas, descriptor, sizeof(QUICImage));
surface = canvas_get_quic(canvas, image, 0);
break;
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
case IMAGE_TYPE_LZ_PLT: {
access_test(canvas, descriptor, sizeof(LZ_PLTImage));
LZImage *image = (LZImage *)descriptor;
surface = canvas_get_lz(canvas, image, 0);
break;
}
case IMAGE_TYPE_LZ_RGB: {
access_test(canvas, descriptor, sizeof(LZ_RGBImage));
LZImage *image = (LZImage *)descriptor;
surface = canvas_get_lz(canvas, image, 0);
break;
}
#endif
#ifdef USE_GLZ
case IMAGE_TYPE_GLZ_RGB: {
access_test(canvas, descriptor, sizeof(LZ_RGBImage));
LZImage *image = (LZImage *)descriptor;
surface = canvas_get_glz(canvas, image);
break;
}
#endif
case IMAGE_TYPE_FROM_CACHE:
return canvas->bits_cache_get(canvas->bits_cache_opaque, descriptor->id);
case IMAGE_TYPE_BITMAP: {
BitmapImage *bitmap = (BitmapImage *)descriptor;
access_test(canvas, descriptor, sizeof(BitmapImage));
surface = canvas_get_bits(canvas, &bitmap->bitmap);
break;
}
default:
CANVAS_ERROR("invalid image type");
}
if (descriptor->flags & IMAGE_CACHE_ME) {
canvas->bits_cache_put(canvas->bits_cache_opaque, descriptor->id, surface);
#ifdef DEBUG_DUMP_SURFACE
dump_surface(surface, 1);
#endif
} else if (descriptor->type != IMAGE_TYPE_FROM_CACHE) {
#ifdef DEBUG_DUMP_SURFACE
dump_surface(surface, 0);
#endif
}
return surface;
}
#else
static cairo_surface_t *canvas_get_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, 0);
}
case IMAGE_TYPE_BITMAP: {
BitmapImage *bitmap = (BitmapImage *)descriptor;
access_test(canvas, descriptor, sizeof(BitmapImage));
return canvas_get_bits(canvas, &bitmap->bitmap);
}
default:
CANVAS_ERROR("invalid image type");
}
}
#endif
static inline uint8_t revers_bits(uint8_t byte)
{
uint8_t ret = 0;
int i;
for (i = 0; i < 4; i++) {
int shift = 7 - i * 2;
ret |= (byte & (1 << i)) << shift;
ret |= (byte & (0x80 >> i)) >> shift;
}
return ret;
}
static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitmap, int invers)
{
cairo_surface_t *surface;
uint8_t *src_line;
uint8_t *end_line;
uint8_t *dest_line;
int src_stride;
int line_size;
int dest_stride;
surface = surface_create(
#ifdef WIN32
canvas->dc,
#endif
CAIRO_FORMAT_A1, bitmap->x, bitmap->y, TRUE);
if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
CANVAS_ERROR("create surface failed, %s",
cairo_status_to_string(cairo_surface_status(surface)));
}
src_line = (uint8_t *)GET_ADDRESS(bitmap->data);
src_stride = bitmap->stride;
end_line = src_line + (bitmap->y * src_stride);
access_test(canvas, src_line, end_line - src_line);
line_size = ALIGN(bitmap->x, 8) >> 3;
dest_stride = cairo_image_surface_get_stride(surface);
dest_line = cairo_image_surface_get_data(surface);
#if defined(GL_CANVAS)
if ((bitmap->flags & BITMAP_TOP_DOWN)) {
#else
if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
#endif
ASSERT(bitmap->y > 0);
dest_line += dest_stride * ((int)bitmap->y - 1);
dest_stride = -dest_stride;
}
if (invers) {
switch (bitmap->format) {
#if defined(GL_CANVAS) || defined(GDI_CANVAS)
case BITMAP_FMT_1BIT_BE:
#else
case BITMAP_FMT_1BIT_LE:
#endif
for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
uint8_t *dest = dest_line;
uint8_t *now = src_line;
uint8_t *end = now + line_size;
while (now < end) {
*(dest++) = ~*(now++);
}
}
break;
#if defined(GL_CANVAS) || defined(GDI_CANVAS)
case BITMAP_FMT_1BIT_LE:
#else
case BITMAP_FMT_1BIT_BE:
#endif
for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
uint8_t *dest = dest_line;
uint8_t *now = src_line;
uint8_t *end = now + line_size;
while (now < end) {
*(dest++) = ~revers_bits(*(now++));
}
}
break;
default:
cairo_surface_destroy(surface);
CANVAS_ERROR("invalid bitmap format");
}
} else {
switch (bitmap->format) {
#if defined(GL_CANVAS) || defined(GDI_CANVAS)
case BITMAP_FMT_1BIT_BE:
#else
case BITMAP_FMT_1BIT_LE:
#endif
for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
memcpy(dest_line, src_line, line_size);
}
break;
#if defined(GL_CANVAS) || defined(GDI_CANVAS)
case BITMAP_FMT_1BIT_LE:
#else
case BITMAP_FMT_1BIT_BE:
#endif
for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
uint8_t *dest = dest_line;
uint8_t *now = src_line;
uint8_t *end = now + line_size;
while (now < end) {
*(dest++) = revers_bits(*(now++));
}
}
break;
default:
cairo_surface_destroy(surface);
CANVAS_ERROR("invalid bitmap format");
}
}
return surface;
}
static inline cairo_surface_t *canvas_A1_invers(cairo_surface_t *src_surf)
{
int width = cairo_image_surface_get_width(src_surf);
int height = cairo_image_surface_get_height(src_surf);
cairo_surface_t * invers = cairo_image_surface_create(CAIRO_FORMAT_A1, width, height);
if (cairo_surface_status(invers) == CAIRO_STATUS_SUCCESS) {
uint8_t *src_line = cairo_image_surface_get_data(src_surf);
int src_stride = cairo_image_surface_get_stride(src_surf);
uint8_t *end_line = src_line + (height * src_stride);
int line_size = ALIGN(width, 8) >> 3;
uint8_t *dest_line = cairo_image_surface_get_data(invers);
int dest_stride = cairo_image_surface_get_stride(invers);
for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
uint8_t *dest = dest_line;
uint8_t *now = src_line;
uint8_t *end = now + line_size;
while (now < end) {
*(dest++) = ~*(now++);
}
}
}
return invers;
}
static cairo_surface_t *canvas_surf_to_invers(cairo_surface_t *surf)
{
int width = cairo_image_surface_get_width(surf);
int height = cairo_image_surface_get_height(surf);
uint8_t *dest_line;
uint8_t *dest_line_end;
uint8_t *src_line;
int dest_stride;
int src_stride;
ASSERT(cairo_image_surface_get_format(surf) == CAIRO_FORMAT_RGB24);
cairo_surface_t *invers = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
if (cairo_surface_status(invers) != CAIRO_STATUS_SUCCESS) {
CANVAS_ERROR("create surface failed, %s",
cairo_status_to_string(cairo_surface_status(invers)));
}
dest_line = cairo_image_surface_get_data(invers);
dest_stride = cairo_image_surface_get_stride(invers);
dest_line_end = dest_line + dest_stride * height;
src_line = cairo_image_surface_get_data(surf);
src_stride = cairo_image_surface_get_stride(surf);
for (; dest_line != dest_line_end; dest_line += dest_stride, src_line += src_stride) {
uint32_t *src = (uint32_t *)src_line;
uint32_t *dest = (uint32_t *)dest_line;
uint32_t *end = dest + width;
while (dest < end) {
*(dest++) = ~*(src++) & 0x00ffffff;
}
}
return invers;
}
/*
* Return the inversed surface and assigns it to the user data of the given surface.
* The routine also handles the reference count of the inversed surface. It you don't use
* the returned reference, you must call cairo_surface_destroy.
* Thread safe with respect to the user data.
*/
static inline cairo_surface_t* canvas_handle_inverse_user_data(cairo_surface_t* surface)
{
cairo_surface_t *inv_surf = NULL;
#ifdef CAIRO_CANVAS_CACH_IS_SHARED
MUTEX_LOCK(cairo_surface_user_data_mutex);
#endif
inv_surf = (cairo_surface_t *)cairo_surface_get_user_data(surface, &invers_data_type);
#ifdef CAIRO_CANVAS_CACH_IS_SHARED
MUTEX_UNLOCK(cairo_surface_user_data_mutex);
#endif
if (!inv_surf) {
if (cairo_image_surface_get_format(surface) == CAIRO_FORMAT_A1) {
inv_surf = canvas_A1_invers(surface);
} else {
inv_surf = canvas_surf_to_invers(surface);
}
if (cairo_surface_status(inv_surf) != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy(inv_surf);
CANVAS_ERROR("create surface failed, %s",
cairo_status_to_string(cairo_surface_status(surface)));
}
#ifdef CAIRO_CANVAS_CACH_IS_SHARED
MUTEX_LOCK(cairo_surface_user_data_mutex);
// checking if other thread has already assigned the user data
if (!cairo_surface_get_user_data(surface, &invers_data_type)) {
#endif
if (cairo_surface_set_user_data(surface, &invers_data_type, inv_surf,
__release_surface) == CAIRO_STATUS_SUCCESS) {
cairo_surface_reference(inv_surf);
}
#ifdef CAIRO_CANVAS_CACH_IS_SHARED
}
MUTEX_UNLOCK(cairo_surface_user_data_mutex);
#endif
} else {
cairo_surface_reference(inv_surf);
}
return inv_surf;
}
static cairo_surface_t *canvas_get_mask(CanvasBase *canvas, QMask *mask)
{
ImageDescriptor *descriptor;
cairo_surface_t *surface;
int need_invers;
int is_invers;
int cache_me;
if (!mask->bitmap) {
return NULL;
}
descriptor = (ImageDescriptor *)GET_ADDRESS(mask->bitmap);
access_test(canvas, descriptor, sizeof(ImageDescriptor));
need_invers = mask->flags & MASK_INVERS;
#ifdef CAIRO_CANVAS_CACHE
cache_me = descriptor->flags & IMAGE_CACHE_ME;
#else
cache_me = 0;
#endif
switch (descriptor->type) {
case IMAGE_TYPE_BITMAP: {
BitmapImage *bitmap = (BitmapImage *)descriptor;
access_test(canvas, descriptor, sizeof(BitmapImage));
is_invers = need_invers && !cache_me;
surface = canvas_get_bitmap_mask(canvas, &bitmap->bitmap, is_invers);
break;
}
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
case IMAGE_TYPE_FROM_CACHE:
surface = canvas->bits_cache_get(canvas->bits_cache_opaque, descriptor->id);
is_invers = 0;
break;
#endif
default:
CANVAS_ERROR("invalid image type");
}
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
if (cache_me) {
canvas->bits_cache_put(canvas->bits_cache_opaque, descriptor->id, surface);
}
if (need_invers && !is_invers) { // surface is in cache
cairo_surface_t *inv_surf;
inv_surf = canvas_handle_inverse_user_data(surface);
cairo_surface_destroy(surface);
surface = inv_surf;
}
#endif
return surface;
}
static inline RasterGlyph *canvas_next_raster_glyph(const RasterGlyph *glyph, int bpp)
{
return (RasterGlyph *)((uint8_t *)(glyph + 1) +
(ALIGN(glyph->width * bpp, 8) * glyph->height >> 3));
}
static inline void canvas_raster_glyph_box(const RasterGlyph *glyph, Rect *r)
{
ASSERT(r);
r->top = glyph->render_pos.y + glyph->glyph_origin.y;
r->bottom = r->top + glyph->height;
r->left = glyph->render_pos.x + glyph->glyph_origin.x;
r->right = r->left + glyph->width;
}
#ifdef GL_CANVAS
static inline void __canvas_put_bits(uint8_t *dest, int offset, uint8_t val, int n)
{
uint8_t mask;
int now;
dest = dest + (offset >> 3);
offset &= 0x07;
now = MIN(8 - offset, n);
mask = ~((1 << (8 - now)) - 1);
mask >>= offset;
*dest = ((val >> offset) & mask) | *dest;
if ((n = n - now)) {
mask = ~((1 << (8 - n)) - 1);
dest++;
*dest = ((val << now) & mask) | *dest;
}
}
#else
static inline void __canvas_put_bits(uint8_t *dest, int offset, uint8_t val, int n)
{
uint8_t mask;
int now;
dest = dest + (offset >> 3);
offset &= 0x07;
now = MIN(8 - offset, n);
mask = (1 << now) - 1;
mask <<= offset;
val = revers_bits(val);
*dest = ((val << offset) & mask) | *dest;
if ((n = n - now)) {
mask = (1 << n) - 1;
dest++;
*dest = ((val >> now) & mask) | *dest;
}
}
#endif
static inline void canvas_put_bits(uint8_t *dest, int dest_offset, uint8_t *src, int n)
{
while (n) {
int now = MIN(n, 8);
n -= now;
__canvas_put_bits(dest, dest_offset, *src, now);
dest_offset += now;
src++;
}
}
static void canvas_put_glyph_bits(RasterGlyph *glyph, int bpp, uint8_t *dest, int dest_stride,
Rect *bounds)
{
Rect glyph_box;
uint8_t *src;
int lines;
int width;
//todo: support STRING_RASTER_TOP_DOWN
canvas_raster_glyph_box(glyph, &glyph_box);
ASSERT(glyph_box.top >= bounds->top && glyph_box.bottom <= bounds->bottom);
ASSERT(glyph_box.left >= bounds->left && glyph_box.right <= bounds->right);
rect_offset(&glyph_box, -bounds->left, -bounds->top);
dest += glyph_box.top * dest_stride;
src = glyph->data;
lines = glyph_box.bottom - glyph_box.top;
width = glyph_box.right - glyph_box.left;
switch (bpp) {
case 1: {
int src_stride = ALIGN(width, 8) >> 3;
int i;
src += src_stride * (lines);
for (i = 0; i < lines; i++) {
src -= src_stride;
canvas_put_bits(dest, glyph_box.left, src, width);
dest += dest_stride;
}
break;
}
case 4: {
uint8_t *end;
int src_stride = ALIGN(width * 4, 8) >> 3;
src += src_stride * lines;
dest += glyph_box.left;
end = dest + dest_stride * lines;
for (; dest != end; dest += dest_stride) {
int i = 0;
uint8_t *now;
src -= src_stride;
now = src;
while (i < (width & ~1)) {
dest[i] = MAX(dest[i], *now & 0xf0);
dest[i + 1] = MAX(dest[i + 1], *now << 4);
i += 2;
now++;
}
if (i < width) {
dest[i] = MAX(dest[i], *now & 0xf0);
now++;
}
}
break;
}
case 8: {
uint8_t *end;
src += width * lines;
dest += glyph_box.left;
end = dest + dest_stride * lines;
for (; dest != end; dest += dest_stride, src -= width) {
int i;
for (i = 0; i < width; i++) {
dest[i] = MAX(dest[i], src[i]);
}
}
break;
}
default:
CANVAS_ERROR("invalid bpp");
}
}
static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, String *str, int bpp, Point *pos)
{
RasterGlyph *glyph = (RasterGlyph *)str->data;
RasterGlyph *next_glyph;
Rect bounds;
cairo_surface_t *str_mask;
uint8_t *dest;
int dest_stride;
int i;
ASSERT(str->length > 0);
access_test(canvas, glyph, sizeof(RasterGlyph));
next_glyph = canvas_next_raster_glyph(glyph, bpp);
access_test(canvas, glyph, (uint8_t*)next_glyph - (uint8_t*)glyph);
canvas_raster_glyph_box(glyph, &bounds);
for (i = 1; i < str->length; i++) {
Rect glyph_box;
glyph = next_glyph;
access_test(canvas, glyph, sizeof(RasterGlyph));
next_glyph = canvas_next_raster_glyph(glyph, bpp);
access_test(canvas, glyph, (uint8_t*)next_glyph - (uint8_t*)glyph);
canvas_raster_glyph_box(glyph, &glyph_box);
rect_union(&bounds, &glyph_box);
}
str_mask = cairo_image_surface_create((bpp == 1) ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8,
bounds.right - bounds.left,
bounds.bottom - bounds.top);
if (cairo_surface_status(str_mask) != CAIRO_STATUS_SUCCESS) {
CANVAS_ERROR("create surface failed, %s",
cairo_status_to_string(cairo_surface_status(str_mask)));
}
dest = cairo_image_surface_get_data(str_mask);
dest_stride = cairo_image_surface_get_stride(str_mask);
glyph = (RasterGlyph *)str->data;
for (i = 0; i < str->length; i++) {
#if defined(GL_CANVAS)
canvas_put_glyph_bits(glyph, bpp, dest + (bounds.bottom - bounds.top - 1) * dest_stride,
-dest_stride, &bounds);
#else
canvas_put_glyph_bits(glyph, bpp, dest, dest_stride, &bounds);
#endif
glyph = canvas_next_raster_glyph(glyph, bpp);
}
pos->x = bounds.left;
pos->y = bounds.top;
return str_mask;
}
static inline VectotGlyph *canvas_next_vector_glyph(const VectotGlyph *glyph)
{
return (VectotGlyph *)((uint8_t *)(glyph + 1) + glyph->data_size);
}
static cairo_surface_t *canvas_scale_surface(cairo_surface_t *src, const Rect *src_area, int width,
int hight, int scale_mode)
{
cairo_t *cairo;
cairo_surface_t *surface;
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
double sx, sy;
surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, hight);
if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
CANVAS_ERROR("create surface failed, %s",
cairo_status_to_string(cairo_surface_status(surface)));
}
cairo = cairo_create(surface);
if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS) {
CANVAS_ERROR("create surface failed, %s", cairo_status_to_string(cairo_status(cairo)));
}
pattern = cairo_pattern_create_for_surface(src);
if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
CANVAS_ERROR("create pattern failed, %s",
cairo_status_to_string(cairo_pattern_status(pattern)));
}
sx = (double)(src_area->right - src_area->left) / width;
sy = (double)(src_area->bottom - src_area->top) / hight;
cairo_matrix_init_translate(&matrix, src_area->left, src_area->top);
cairo_matrix_scale(&matrix, sx, sy);
cairo_pattern_set_matrix(pattern, &matrix);
ASSERT(scale_mode == IMAGE_SCALE_INTERPOLATE || scale_mode == IMAGE_SCALE_NEAREST);
cairo_pattern_set_filter(pattern, (scale_mode == IMAGE_SCALE_NEAREST) ?
CAIRO_FILTER_NEAREST : CAIRO_FILTER_GOOD);
cairo_set_source(cairo, pattern);
cairo_pattern_destroy(pattern);
cairo_paint(cairo);
cairo_destroy(cairo);
return surface;
}
static void quic_usr_error(QuicUsrContext *usr, const char *fmt, ...)
{
QuicData *usr_data = (QuicData *)usr;
va_list ap;
va_start(ap, fmt);
vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
va_end(ap);
longjmp(usr_data->jmp_env, 1);
}
static void quic_usr_warn(QuicUsrContext *usr, const char *fmt, ...)
{
QuicData *usr_data = (QuicData *)usr;
va_list ap;
va_start(ap, fmt);
vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
va_end(ap);
}
static void *quic_usr_malloc(QuicUsrContext *usr, int size)
{
return malloc(size);
}
static void quic_usr_free(QuicUsrContext *usr, void *ptr)
{
free(ptr);
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
{
return 0;
}
static void lz_usr_warn(LzUsrContext *usr, const char *fmt, ...)
{
LzData *usr_data = (LzData *)usr;
va_list ap;
va_start(ap, fmt);
vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
va_end(ap);
}
static void lz_usr_error(LzUsrContext *usr, const char *fmt, ...)
{
LzData *usr_data = (LzData *)usr;
va_list ap;
va_start(ap, fmt);
vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
va_end(ap);
longjmp(usr_data->jmp_env, 1);
}
static void *lz_usr_malloc(LzUsrContext *usr, int size)
{
return malloc(size);
}
static void lz_usr_free(LzUsrContext *usr, void *ptr)
{
free(ptr);
}
static int lz_usr_more_space(LzUsrContext *usr, uint8_t **io_ptr)
{
return 0;
}
static int lz_usr_more_lines(LzUsrContext *usr, uint8_t **lines)
{
return 0;
}
#else
static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
{
QuicData *quic_data = (QuicData *)usr;
DataChunk *chunk;
uint32_t size;
if (!quic_data->next) {
return 0;
}
chunk = (DataChunk *)quic_data->get_virt(quic_data->get_virt_opaque, quic_data->next,
sizeof(DataChunk));
size = chunk->size;
quic_data->validate_virt(quic_data->validate_virt_opaque, (unsigned long)chunk->data,
quic_data->next, size);
quic_data->next = chunk->next;
*io_ptr = (uint32_t *)chunk->data;
return size >> 2;
}
#endif
static int quic_usr_more_lines(QuicUsrContext *usr, uint8_t **lines)
{
return 0;
}
#ifdef CAIRO_CANVAS_ACCESS_TEST
static void __canvas_set_access_params(CanvasBase *canvas, unsigned long base, unsigned long max)
{
canvas->base = base;
canvas->max = max;
}
#endif
static void canvas_base_destroy(CanvasBase *canvas)
{
quic_destroy(canvas->quic_data.quic);
#ifdef CAIRO_CANVAS_NO_CHUNKS
lz_destroy(canvas->lz_data.lz);
#endif
#ifdef GDI_CANVAS
DeleteDC(canvas->dc);
#endif
}
#ifdef CAIRO_CANVAS_CACHE
static int canvas_base_init(CanvasBase *canvas, int depth,
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)
static int canvas_base_init(CanvasBase *canvas, int depth,
void *bits_cache_opaque,
bits_cache_put_fn_t bits_cache_put,
bits_cache_get_fn_t bits_cache_get
#else
static int canvas_base_init(CanvasBase *canvas, int depth
#endif
#ifdef USE_GLZ
, void *glz_decoder_opaque, glz_decode_fn_t glz_decode
#endif
#ifndef CAIRO_CANVAS_NO_CHUNKS
, void *get_virt_opaque, get_virt_fn_t get_virt,
void *validate_virt_opaque, validate_virt_fn_t validate_virt
#endif
)
{
canvas->quic_data.usr.error = quic_usr_error;
canvas->quic_data.usr.warn = quic_usr_warn;
canvas->quic_data.usr.info = quic_usr_warn;
canvas->quic_data.usr.malloc = quic_usr_malloc;
canvas->quic_data.usr.free = quic_usr_free;
canvas->quic_data.usr.more_space = quic_usr_more_space;
canvas->quic_data.usr.more_lines = quic_usr_more_lines;
#ifndef CAIRO_CANVAS_NO_CHUNKS
canvas->quic_data.get_virt_opaque = get_virt_opaque;
canvas->quic_data.get_virt = get_virt;
canvas->quic_data.validate_virt_opaque = validate_virt_opaque;
canvas->quic_data.validate_virt = validate_virt;
#endif
if (!(canvas->quic_data.quic = quic_create(&canvas->quic_data.usr))) {
return 0;
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
canvas->lz_data.usr.error = lz_usr_error;
canvas->lz_data.usr.warn = lz_usr_warn;
canvas->lz_data.usr.info = lz_usr_warn;
canvas->lz_data.usr.malloc = lz_usr_malloc;
canvas->lz_data.usr.free = lz_usr_free;
canvas->lz_data.usr.more_space = lz_usr_more_space;
canvas->lz_data.usr.more_lines = lz_usr_more_lines;
if (!(canvas->lz_data.lz = lz_create(&canvas->lz_data.usr))) {
return 0;
}
#endif
#ifdef USE_GLZ
canvas->glz_data.decoder_opaque = glz_decoder_opaque;
canvas->glz_data.decode = glz_decode;
#endif
if (depth == 16) {
canvas->color_shift = 5;
canvas->color_mask = 0x1f;
} else {
canvas->color_shift = 8;
canvas->color_mask = 0xff;
}
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
canvas->bits_cache_opaque = bits_cache_opaque;
canvas->bits_cache_put = bits_cache_put;
canvas->bits_cache_get = bits_cache_get;
#endif
#ifdef CAIRO_CANVAS_CACHE
canvas->palette_cache_opaque = palette_cache_opaque;
canvas->palette_cache_put = palette_cache_put;
canvas->palette_cache_get = palette_cache_get;
canvas->palette_cache_release = palette_cache_release;
#endif
#ifdef WIN32
canvas->dc = NULL;
#endif
#ifdef GDI_CANVAS
canvas->dc = create_compatible_dc();
if (!canvas->dc) {
lz_destroy(canvas->lz_data.lz);
return 0;
}
#endif
return 1;
}
Reference in New Issue View Git Blame Copy Permalink