[Spice-devel] [PATCH 1/5] Use the spice-common submodule
Marc-André Lureau
marcandre.lureau at gmail.com
Wed Mar 14 18:13:31 PDT 2012
This patch will replace the common/ directory with the spice-common
project. It is for now a simple project subdirectory shared with
spice-gtk, but the goal is to make it a proper library later on.
With this change, the spice-server build is broken. The following
commits fix the build, and have been seperated to ease the review.
---
.gitmodules | 3 +
common | 1 +
common/.gitignore | 9 -
common/Makefile.am | 76 -
common/backtrace.c | 133 --
common/backtrace.h | 34 -
common/bitops.h | 91 -
common/canvas_base.c | 3394 ------------------------------
common/canvas_base.h | 327 ---
common/canvas_utils.c | 299 ---
common/canvas_utils.h | 80 -
common/draw.h | 281 ---
common/gdi_canvas.c | 1858 ----------------
common/gdi_canvas.h | 51 -
common/gl_canvas.c | 906 --------
common/gl_canvas.h | 53 -
common/gl_utils.h | 61 -
common/glc.c | 1513 -------------
common/glc.h | 167 --
common/lines.c | 3613 --------------------------------
common/lines.h | 138 --
common/lz.c | 740 -------
common/lz.h | 82 -
common/lz_common.h | 69 -
common/lz_compress_tmpl.c | 529 -----
common/lz_config.h | 39 -
common/lz_decompress_tmpl.c | 326 ---
common/marshaller.c | 615 ------
common/marshaller.h | 74 -
common/mem.c | 297 ---
common/mem.h | 162 --
common/messages.h | 525 -----
common/mutex.h | 44 -
common/ogl_ctx.c | 251 ---
common/ogl_ctx.h | 38 -
common/pixman_utils.c | 1594 --------------
common/pixman_utils.h | 136 --
common/quic.c | 1699 ---------------
common/quic.h | 72 -
common/quic_config.h | 48 -
common/quic_family_tmpl.c | 117 -
common/quic_rgb_tmpl.c | 765 -------
common/quic_tmpl.c | 635 ------
common/rect.h | 122 --
common/region.c | 890 --------
common/region.h | 70 -
common/ring.h | 172 --
common/rop3.c | 650 ------
common/rop3.h | 42 -
common/spice_common.h | 78 -
common/ssl_verify.c | 482 -----
common/ssl_verify.h | 66 -
common/sw_canvas.c | 1327 ------------
common/sw_canvas.h | 70 -
common/win/Makefile.am | 1 -
common/win/my_getopt-1.5/ChangeLog | 22 -
common/win/my_getopt-1.5/LICENSE | 22 -
common/win/my_getopt-1.5/Makefile.am | 14 -
common/win/my_getopt-1.5/Makefile.test | 26 -
common/win/my_getopt-1.5/README | 140 --
common/win/my_getopt-1.5/getopt.3 | 288 ---
common/win/my_getopt-1.5/getopt.h | 56 -
common/win/my_getopt-1.5/getopt.txt | 330 ---
common/win/my_getopt-1.5/main.c | 387 ----
common/win/my_getopt-1.5/my_getopt.c | 281 ---
common/win/my_getopt-1.5/my_getopt.h | 72 -
66 files changed, 4 insertions(+), 27549 deletions(-)
create mode 160000 common
delete mode 100644 common/.gitignore
delete mode 100644 common/Makefile.am
delete mode 100644 common/backtrace.c
delete mode 100644 common/backtrace.h
delete mode 100644 common/bitops.h
delete mode 100644 common/canvas_base.c
delete mode 100644 common/canvas_base.h
delete mode 100644 common/canvas_utils.c
delete mode 100644 common/canvas_utils.h
delete mode 100644 common/draw.h
delete mode 100644 common/gdi_canvas.c
delete mode 100644 common/gdi_canvas.h
delete mode 100644 common/gl_canvas.c
delete mode 100644 common/gl_canvas.h
delete mode 100644 common/gl_utils.h
delete mode 100644 common/glc.c
delete mode 100644 common/glc.h
delete mode 100644 common/lines.c
delete mode 100644 common/lines.h
delete mode 100644 common/lz.c
delete mode 100644 common/lz.h
delete mode 100644 common/lz_common.h
delete mode 100644 common/lz_compress_tmpl.c
delete mode 100644 common/lz_config.h
delete mode 100644 common/lz_decompress_tmpl.c
delete mode 100644 common/marshaller.c
delete mode 100644 common/marshaller.h
delete mode 100644 common/mem.c
delete mode 100644 common/mem.h
delete mode 100644 common/messages.h
delete mode 100644 common/mutex.h
delete mode 100644 common/ogl_ctx.c
delete mode 100644 common/ogl_ctx.h
delete mode 100644 common/pixman_utils.c
delete mode 100644 common/pixman_utils.h
delete mode 100644 common/quic.c
delete mode 100644 common/quic.h
delete mode 100644 common/quic_config.h
delete mode 100644 common/quic_family_tmpl.c
delete mode 100644 common/quic_rgb_tmpl.c
delete mode 100644 common/quic_tmpl.c
delete mode 100644 common/rect.h
delete mode 100644 common/region.c
delete mode 100644 common/region.h
delete mode 100644 common/ring.h
delete mode 100644 common/rop3.c
delete mode 100644 common/rop3.h
delete mode 100644 common/spice_common.h
delete mode 100644 common/ssl_verify.c
delete mode 100644 common/ssl_verify.h
delete mode 100644 common/sw_canvas.c
delete mode 100644 common/sw_canvas.h
delete mode 100644 common/win/Makefile.am
delete mode 100644 common/win/my_getopt-1.5/ChangeLog
delete mode 100644 common/win/my_getopt-1.5/LICENSE
delete mode 100644 common/win/my_getopt-1.5/Makefile.am
delete mode 100644 common/win/my_getopt-1.5/Makefile.test
delete mode 100644 common/win/my_getopt-1.5/README
delete mode 100644 common/win/my_getopt-1.5/getopt.3
delete mode 100644 common/win/my_getopt-1.5/getopt.h
delete mode 100644 common/win/my_getopt-1.5/getopt.txt
delete mode 100644 common/win/my_getopt-1.5/main.c
delete mode 100644 common/win/my_getopt-1.5/my_getopt.c
delete mode 100644 common/win/my_getopt-1.5/my_getopt.h
diff --git a/.gitmodules b/.gitmodules
index f7de75d..6981ae4 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,6 @@
[submodule "spice-protocol"]
path = spice-protocol
url = ../spice-protocol
+[submodule "common"]
+ path = common
+ url = ../spice-common
diff --git a/common b/common
new file mode 160000
index 0000000..e610cee
--- /dev/null
+++ b/common
@@ -0,0 +1 @@
+Subproject commit 0da9c0d6ac4d709e00dd92b744cdd9f1bd1ca7de
diff --git a/common/.gitignore b/common/.gitignore
deleted file mode 100644
index d033f47..0000000
--- a/common/.gitignore
+++ /dev/null
@@ -1,9 +0,0 @@
-*.la
-*.lo
-*.loT
-*.o
-.deps
-.dirstamp
-.libs
-Makefile
-Makefile.in
diff --git a/common/Makefile.am b/common/Makefile.am
deleted file mode 100644
index 4189dc1..0000000
--- a/common/Makefile.am
+++ /dev/null
@@ -1,76 +0,0 @@
-if OS_WIN32
-SUBDIRS = win
-endif
-
-NULL =
-
-noinst_LTLIBRARIES = libspice-common.la
-libspice_common_la_SOURCES = \
- bitops.h \
- canvas_utils.c \
- canvas_utils.h \
- draw.h \
- lines.c \
- lines.h \
- lz.c \
- lz.h \
- lz_common.h \
- lz_config.h \
- marshaller.c \
- marshaller.h \
- mem.c \
- mem.h \
- messages.h \
- mutex.h \
- pixman_utils.c \
- pixman_utils.h \
- quic.c \
- quic.h \
- quic_config.h \
- rect.h \
- region.c \
- region.h \
- ring.h \
- rop3.c \
- rop3.h \
- spice_common.h \
- ssl_verify.c \
- ssl_verify.h \
- backtrace.c \
- backtrace.h \
- $(NULL)
-
-if SUPPORT_GL
-libspice_common_la_SOURCES += \
- gl_utils.h \
- glc.h \
- glc.c \
- ogl_ctx.h \
- ogl_ctx.c \
- $(NULL)
-endif
-
-INCLUDES = \
- $(GL_CFLAGS) \
- $(PIXMAN_CFLAGS) \
- $(PROTOCOL_CFLAGS) \
- $(VISIBILITY_HIDDEN_CFLAGS) \
- $(WARN_CFLAGS) \
- -std=gnu99 \
- $(NULL)
-
-EXTRA_DIST = \
- canvas_base.c \
- canvas_base.h \
- gdi_canvas.c \
- gdi_canvas.h \
- gl_canvas.c \
- gl_canvas.h \
- sw_canvas.c \
- sw_canvas.h \
- lz_compress_tmpl.c \
- lz_decompress_tmpl.c \
- quic_family_tmpl.c \
- quic_rgb_tmpl.c \
- quic_tmpl.c \
- $(NULL)
diff --git a/common/backtrace.c b/common/backtrace.c
deleted file mode 100644
index c8f4626..0000000
--- a/common/backtrace.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2011 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
- * Taken from xserver os/backtrace.c:
- * Copyright (C) 2008 Red Hat, Inc.
- */
-
-#include <config.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <sys/types.h>
-#ifndef __MINGW32__
-#include <sys/wait.h>
-#endif
-
-#include "spice_common.h"
-
-#define GSTACK_PATH "/usr/bin/gstack"
-
-#if HAVE_EXECINFO_H
-#include <execinfo.h>
-
-static void spice_backtrace_backtrace(void)
-{
- void *array[100];
- int size;
-
- size = backtrace(array, sizeof(array)/sizeof(array[0]));
- backtrace_symbols_fd(array, size, STDERR_FILENO);
-}
-#else
-static void spice_backtrace_backtrace(void)
-{
-}
-#endif
-
-/* XXX perhaps gstack can be available in windows but pipe/waitpid isn't,
- * so until it is ported properly just compile it out, we lose the
- * backtrace only. */
-#ifndef __MINGW32__
-static int spice_backtrace_gstack(void)
-{
- pid_t kidpid;
- int pipefd[2];
-
- if (pipe(pipefd) != 0) {
- return -1;
- }
-
- kidpid = fork();
-
- if (kidpid == -1) {
- /* ERROR */
- return -1;
- } else if (kidpid == 0) {
- /* CHILD */
- char parent[16];
-
- seteuid(0);
- close(STDIN_FILENO);
- close(STDOUT_FILENO);
- dup2(pipefd[1],STDOUT_FILENO);
- close(STDERR_FILENO);
-
- snprintf(parent, sizeof(parent), "%d", getppid());
- execle(GSTACK_PATH, "gstack", parent, NULL, NULL);
- exit(1);
- } else {
- /* PARENT */
- char btline[256];
- int kidstat;
- int bytesread;
- int done = 0;
-
- close(pipefd[1]);
-
- while (!done) {
- bytesread = read(pipefd[0], btline, sizeof(btline) - 1);
-
- if (bytesread > 0) {
- btline[bytesread] = 0;
- fprintf(stderr, "%s", btline);
- }
- else if ((bytesread == 0) ||
- ((errno != EINTR) && (errno != EAGAIN))) {
- done = 1;
- }
- }
- close(pipefd[0]);
- waitpid(kidpid, &kidstat, 0);
- if (kidstat != 0)
- return -1;
- }
- return 0;
-}
-#else
-static int spice_backtrace_gstack(void)
-{
- /* empty failing implementation */
- return -1;
-}
-#endif
-
-void spice_backtrace(void)
-{
- int ret = -1;
-
- if (!access(GSTACK_PATH, X_OK)) {
- ret = spice_backtrace_gstack();
- }
- if (ret != 0) {
- spice_backtrace_backtrace();
- }
-}
diff --git a/common/backtrace.h b/common/backtrace.h
deleted file mode 100644
index 894c027..0000000
--- a/common/backtrace.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2011 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef BACKTRACE_H
-#define BACKTRACE_H
-
-#include <spice/macros.h>
-
-SPICE_BEGIN_DECLS
-
-#if defined(WIN32) && !defined(__MINGW32__)
-#define spice_backtrace()
-#else
-void spice_backtrace(void);
-#endif
-
-SPICE_END_DECLS
-
-#endif // BACKTRACE_H
diff --git a/common/bitops.h b/common/bitops.h
deleted file mode 100644
index bdd862a..0000000
--- a/common/bitops.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
-
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#ifndef BITOPS_H
-#define BITOPS_H
-
-#include <spice/macros.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-static inline int spice_bit_find_msb(unsigned int val)
-{
- int ret;
-
- asm ("bsrl %1,%0\n\t"
- "jnz 1f\n\t"
- "movl $-1,%0\n"
- "1:"
- : "=r"(ret) : "r"(val));
- return ret + 1;
-}
-
-#elif defined(WIN32) && !defined(_WIN64)
-static INLINE int spice_bit_find_msb(uint32_t val)
-{
- uint32_t r;
- __asm {
- bsr eax, val
- jnz found
- mov eax, -1
-
-found:
- mov r, eax
- }
- return r + 1;
-}
-
-#else
-static INLINE int spice_bit_find_msb(unsigned int val)
-{
- signed char index = 31;
-
- if(val == 0) {
- return 0;
- }
-
- do {
- if(val & 0x80000000) {
- break;
- }
- val <<= 1;
- } while(--index >= 0);
-
- return index+1;
-}
-
-#endif
-
-static INLINE int spice_bit_next_pow2(unsigned int val)
-{
- if ((val & (val - 1)) == 0) {
- return val;
- }
- return 1 << spice_bit_find_msb(val);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/canvas_base.c b/common/canvas_base.c
deleted file mode 100644
index c4203dd..0000000
--- a/common/canvas_base.c
+++ /dev/null
@@ -1,3394 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This file shouldn't be compiled directly"
-#endif
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdarg.h>
-#include <stdlib.h>
-#include <setjmp.h>
-#include <stdio.h>
-#include <math.h>
-
-#include <spice/macros.h>
-#include "quic.h"
-#include "lz.h"
-#include "canvas_base.h"
-#include "pixman_utils.h"
-#include "canvas_utils.h"
-#include "rect.h"
-#include "lines.h"
-#include "rop3.h"
-#include "mem.h"
-
-#include "mutex.h"
-
-#ifndef CANVAS_ERROR
-#define CANVAS_ERROR(format, ...) { \
- printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__); \
- 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
-
-#define ROUND(_x) ((int)floor((_x) + 0.5))
-
-#define IS_IMAGE_LOSSY(descriptor) \
- (((descriptor)->type == SPICE_IMAGE_TYPE_JPEG) || \
- ((descriptor)->type == SPICE_IMAGE_TYPE_JPEG_ALPHA))
-
- static inline int fix_to_int(SPICE_FIXED28_4 fixed)
-{
- int val, rem;
-
- rem = fixed & 0x0f;
- val = fixed >> 4;
- if (rem > 8) {
- val++;
- }
- return val;
-}
-
- static inline SPICE_FIXED28_4 int_to_fix(int v)
-{
- return v << 4;
-}
-
-static inline double fix_to_double(SPICE_FIXED28_4 fixed)
-{
- return (double)(fixed & 0x0f) / 0x0f + (fixed >> 4);
-}
-
-static inline uint16_t rgb_32_to_16_555(uint32_t color)
-{
- return
- (((color) >> 3) & 0x001f) |
- (((color) >> 6) & 0x03e0) |
- (((color) >> 9) & 0x7c00);
-}
-static inline uint16_t rgb_32_to_16_565(uint32_t color)
-{
- return
- (((color) >> 3) & 0x001f) |
- (((color) >> 5) & 0x07e0) |
- (((color) >> 8) & 0xf800);
-}
-
-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;
-}
-#if defined(WIN32) && defined(GDI_CANVAS)
-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 {
- SpiceGlzDecoder *decoder;
- LzDecodeUsrData decode_data;
-} GlzData;
-
-typedef struct QuicData {
- QuicUsrContext usr;
- QuicContext *quic;
- jmp_buf jmp_env;
- char message_buf[512];
- SpiceChunks *chunks;
- uint32_t current_chunk;
-} QuicData;
-
-typedef struct CanvasBase {
- SpiceCanvas parent;
- uint32_t color_shift;
- uint32_t color_mask;
- QuicData quic_data;
-
- uint32_t format;
- int width;
- int height;
- pixman_region32_t canvas_region;
-
-#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
- SpiceImageCache *bits_cache;
-#endif
-#ifdef SW_CANVAS_CACHE
- SpicePaletteCache *palette_cache;
-#endif
-#ifdef WIN32
- HDC dc;
-#endif
-
- SpiceImageSurfaces *surfaces;
-
- LzData lz_data;
- GlzData glz_data;
- SpiceJpegDecoder* jpeg;
- SpiceZlibDecoder* zlib;
-
- void *usr_data;
- spice_destroy_fn_t usr_data_destroy;
-} CanvasBase;
-
-typedef enum {
- ROP_INPUT_SRC,
- ROP_INPUT_BRUSH,
- ROP_INPUT_DEST
-} ROPInput;
-
-static SpiceROP ropd_descriptor_to_rop(int desc,
- ROPInput src_input,
- ROPInput dest_input)
-{
- int old;
- int invert_masks[] = {
- SPICE_ROPD_INVERS_SRC,
- SPICE_ROPD_INVERS_BRUSH,
- SPICE_ROPD_INVERS_DEST
- };
-
- old = desc;
-
- desc &= ~(SPICE_ROPD_INVERS_SRC | SPICE_ROPD_INVERS_DEST);
- if (old & invert_masks[src_input]) {
- desc |= SPICE_ROPD_INVERS_SRC;
- }
-
- if (old & invert_masks[dest_input]) {
- desc |= SPICE_ROPD_INVERS_DEST;
- }
-
- if (desc & SPICE_ROPD_OP_PUT) {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_RES) {
- return SPICE_ROP_COPY;
- }
- return SPICE_ROP_COPY_INVERTED;
- } else {
- if (desc & SPICE_ROPD_INVERS_RES) {
- return SPICE_ROP_COPY_INVERTED;
- }
- return SPICE_ROP_COPY;
- }
- } else if (desc & SPICE_ROPD_OP_OR) {
-
- if (desc & SPICE_ROPD_INVERS_RES) {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !(!src or !dest) == src and dest*/
- return SPICE_ROP_AND;
- } else {
- /* ! (!src or dest) = src and !dest*/
- return SPICE_ROP_AND_REVERSE;
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !(src or !dest) == !src and dest */
- return SPICE_ROP_AND_INVERTED;
- } else {
- /* !(src or dest) */
- return SPICE_ROP_NOR;
- }
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !src or !dest == !(src and dest)*/
- return SPICE_ROP_NAND;
- } else {
- /* !src or dest */
- return SPICE_ROP_OR_INVERTED;
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* src or !dest */
- return SPICE_ROP_OR_REVERSE;
- } else {
- /* src or dest */
- return SPICE_ROP_OR;
- }
- }
- }
-
- } else if (desc & SPICE_ROPD_OP_AND) {
-
- if (desc & SPICE_ROPD_INVERS_RES) {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !(!src and !dest) == src or dest*/
- return SPICE_ROP_OR;
- } else {
- /* ! (!src and dest) = src or !dest*/
- return SPICE_ROP_OR_REVERSE;
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !(src and !dest) == !src or dest */
- return SPICE_ROP_OR_INVERTED;
- } else {
- /* !(src and dest) */
- return SPICE_ROP_NAND;
- }
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !src and !dest == !(src or dest)*/
- return SPICE_ROP_NOR;
- } else {
- /* !src and dest */
- return SPICE_ROP_AND_INVERTED;
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* src and !dest */
- return SPICE_ROP_AND_REVERSE;
- } else {
- /* src and dest */
- return SPICE_ROP_AND;
- }
- }
- }
-
- } else if (desc & SPICE_ROPD_OP_XOR) {
-
- if (desc & SPICE_ROPD_INVERS_RES) {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !(!src xor !dest) == !src xor dest */
- return SPICE_ROP_EQUIV;
- } else {
- /* ! (!src xor dest) = src xor dest*/
- return SPICE_ROP_XOR;
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !(src xor !dest) == src xor dest */
- return SPICE_ROP_XOR;
- } else {
- /* !(src xor dest) */
- return SPICE_ROP_EQUIV;
- }
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_SRC) {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* !src xor !dest == src xor dest */
- return SPICE_ROP_XOR;
- } else {
- /* !src xor dest */
- return SPICE_ROP_EQUIV;
- }
- } else {
- if (desc & SPICE_ROPD_INVERS_DEST) {
- /* src xor !dest */
- return SPICE_ROP_EQUIV;
- } else {
- /* src xor dest */
- return SPICE_ROP_XOR;
- }
- }
- }
-
- } else if (desc & SPICE_ROPD_OP_BLACKNESS) {
- return SPICE_ROP_CLEAR;
- } else if (desc & SPICE_ROPD_OP_WHITENESS) {
- return SPICE_ROP_SET;
- } else if (desc & SPICE_ROPD_OP_INVERS) {
- return SPICE_ROP_INVERT;
- }
- return SPICE_ROP_COPY;
-}
-
-//#define DEBUG_DUMP_COMPRESS
-#ifdef DEBUG_DUMP_COMPRESS
-static void dump_surface(pixman_image_t *surface, int cache);
-#endif
-
-
-static pixman_format_code_t canvas_get_target_format(CanvasBase *canvas,
- int source_has_alpha)
-{
- pixman_format_code_t format;
-
- /* Convert to target surface format */
- format = spice_surface_format_to_pixman (canvas->format);
-
- if (source_has_alpha) {
- /* Even though the destination has no alpha, we make the source
- * remember there are alpha bits instead of throwing away this
- * information. The results are the same if alpha is not
- * interpreted, and if need to interpret alpha, don't use
- * conversion to target format.
- * This is needed for instance when doing the final
- * canvas_get_target_format() in canvas_get_image_internal
- * as otherwise we wouldn't know if the bitmap source
- * really had alpha.
- */
- if (format == PIXMAN_x8r8g8b8) {
- format = PIXMAN_a8r8g8b8;
- }
- } else { /* !source_has_alpha */
- /* If the source doesn't have alpha, but the destination has,
- don't convert to alpha, since that would just do an unnecessary
- copy to fill the alpha bytes with 0xff which is not expected if
- we just use the raw bits, (and handled implicitly by pixman if
- we're interpreting data) */
- if (format == PIXMAN_a8r8g8b8) {
- format = PIXMAN_x8r8g8b8;
- }
- }
-
- return format;
-}
-
-static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceImage *image,
- int invers, int want_original)
-{
- pixman_image_t *surface = NULL;
- QuicData *quic_data = &canvas->quic_data;
- QuicImageType type, as_type;
- pixman_format_code_t pixman_format;
- uint8_t *dest;
- int stride;
- int width;
- int height;
-
- if (setjmp(quic_data->jmp_env)) {
- pixman_image_unref(surface);
- CANVAS_ERROR("quic error, %s", quic_data->message_buf);
- }
-
- quic_data->chunks = image->u.quic.data;
- quic_data->current_chunk = 0;
-
- if (quic_decode_begin(quic_data->quic,
- (uint32_t *)image->u.quic.data->chunk[0].data,
- image->u.quic.data->chunk[0].len >> 2,
- &type, &width, &height) == QUIC_ERROR) {
- CANVAS_ERROR("quic decode begin failed");
- }
-
- switch (type) {
- case QUIC_IMAGE_TYPE_RGBA:
- as_type = QUIC_IMAGE_TYPE_RGBA;
- pixman_format = PIXMAN_a8r8g8b8;
- break;
- case QUIC_IMAGE_TYPE_RGB32:
- case QUIC_IMAGE_TYPE_RGB24:
- as_type = QUIC_IMAGE_TYPE_RGB32;
- pixman_format = PIXMAN_x8r8g8b8;
- break;
- case QUIC_IMAGE_TYPE_RGB16:
- if (!want_original &&
- (canvas->format == SPICE_SURFACE_FMT_32_xRGB ||
- canvas->format == SPICE_SURFACE_FMT_32_ARGB)) {
- as_type = QUIC_IMAGE_TYPE_RGB32;
- pixman_format = PIXMAN_x8r8g8b8;
- } else {
- as_type = QUIC_IMAGE_TYPE_RGB16;
- pixman_format = PIXMAN_x1r5g5b5;
- }
- 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
- pixman_format,
- width, height, FALSE);
-
- if (surface == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- dest = (uint8_t *)pixman_image_get_data(surface);
- stride = pixman_image_get_stride(surface);
- if (quic_decode(quic_data->quic, as_type,
- dest, stride) == QUIC_ERROR) {
- pixman_image_unref(surface);
- 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 ^= 0xffffffff;
- }
- }
- }
-
-#ifdef DEBUG_DUMP_COMPRESS
- dump_surface(surface, 0);
-#endif
- return surface;
-}
-
-
-//#define DUMP_JPEG
-#ifdef DUMP_JPEG
-static int jpeg_id = 0;
-static void dump_jpeg(uint8_t* data, int data_size)
-{
- char file_str[200];
- uint32_t id = ++jpeg_id;
-
-#ifdef WIN32
- sprintf(file_str, "c:\\tmp\\spice_dump\\%u.jpg", id);
-#else
- sprintf(file_str, "/tmp/spice_dump/%u.jpg", id);
-#endif
-
- FILE *f = fopen(file_str, "wb");
- if (!f) {
- return;
- }
-
- fwrite(data, 1, data_size, f);
- fclose(f);
-}
-#endif
-
-static pixman_image_t *canvas_get_jpeg(CanvasBase *canvas, SpiceImage *image, int invers)
-{
- pixman_image_t *surface = NULL;
- int stride;
- int width;
- int height;
- uint8_t *dest;
-
- ASSERT(image->u.jpeg.data->num_chunks == 1); /* TODO: Handle chunks */
- canvas->jpeg->ops->begin_decode(canvas->jpeg, image->u.jpeg.data->chunk[0].data, image->u.jpeg.data->chunk[0].len,
- &width, &height);
- ASSERT((uint32_t)width == image->descriptor.width);
- ASSERT((uint32_t)height == image->descriptor.height);
-
- surface = surface_create(
-#ifdef WIN32
- canvas->dc,
-#endif
- PIXMAN_x8r8g8b8,
- width, height, FALSE);
- if (surface == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- dest = (uint8_t *)pixman_image_get_data(surface);
- stride = pixman_image_get_stride(surface);
-
- canvas->jpeg->ops->decode(canvas->jpeg, dest, stride, SPICE_BITMAP_FMT_32BIT);
-
- 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 DUMP_JPEG
- dump_jpeg(image->u.jpeg.data, image->u.jpeg.data_size);
-#endif
- return surface;
-}
-
-static pixman_image_t *canvas_get_jpeg_alpha(CanvasBase *canvas,
- SpiceImage *image, int invers)
-{
- pixman_image_t *surface = NULL;
- int stride;
- int width;
- int height;
- uint8_t *dest;
- int alpha_top_down = FALSE;
- LzData *lz_data = &canvas->lz_data;
- LzImageType lz_alpha_type;
- uint8_t *comp_alpha_buf = NULL;
- uint8_t *decomp_alpha_buf = NULL;
- int alpha_size;
- int lz_alpha_width, lz_alpha_height, n_comp_pixels, lz_alpha_top_down;
-
- ASSERT(image->u.jpeg_alpha.data->num_chunks == 1);
- canvas->jpeg->ops->begin_decode(canvas->jpeg,
- image->u.jpeg_alpha.data->chunk[0].data,
- image->u.jpeg_alpha.jpeg_size,
- &width, &height);
- ASSERT((uint32_t)width == image->descriptor.width);
- ASSERT((uint32_t)height == image->descriptor.height);
-
- if (image->u.jpeg_alpha.flags & SPICE_JPEG_ALPHA_FLAGS_TOP_DOWN) {
- alpha_top_down = TRUE;
- }
-
-#ifdef WIN32
- lz_data->decode_data.dc = canvas->dc;
-#endif
- surface = alloc_lz_image_surface(&lz_data->decode_data, PIXMAN_a8r8g8b8,
- width, height, width*height, alpha_top_down);
-
- if (surface == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- dest = (uint8_t *)pixman_image_get_data(surface);
- stride = pixman_image_get_stride(surface);
-
- canvas->jpeg->ops->decode(canvas->jpeg, dest, stride, SPICE_BITMAP_FMT_32BIT);
-
- comp_alpha_buf = image->u.jpeg_alpha.data->chunk[0].data + image->u.jpeg_alpha.jpeg_size;
- alpha_size = image->u.jpeg_alpha.data_size - image->u.jpeg_alpha.jpeg_size;
-
- lz_decode_begin(lz_data->lz, comp_alpha_buf, alpha_size, &lz_alpha_type,
- &lz_alpha_width, &lz_alpha_height, &n_comp_pixels,
- &lz_alpha_top_down, NULL);
- ASSERT(lz_alpha_type == LZ_IMAGE_TYPE_XXXA);
- ASSERT(!!lz_alpha_top_down == !!alpha_top_down);
- ASSERT(lz_alpha_width == width);
- ASSERT(lz_alpha_height == height);
- ASSERT(n_comp_pixels == width * height);
-
- if (!alpha_top_down) {
- decomp_alpha_buf = dest + stride * (height - 1);
- } else {
- decomp_alpha_buf = dest;
- }
- lz_decode(lz_data->lz, LZ_IMAGE_TYPE_XXXA, decomp_alpha_buf);
-
- 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 DUMP_JPEG
- dump_jpeg(image->u.jpeg_alpha.data, image->u.jpeg_alpha.jpeg_size);
-#endif
- return surface;
-}
-
-static pixman_image_t *canvas_bitmap_to_surface(CanvasBase *canvas, SpiceBitmap* bitmap,
- SpicePalette *palette, int want_original)
-{
- uint8_t* src;
- pixman_image_t *image;
- pixman_format_code_t format;
-
- spice_chunks_linearize(bitmap->data);
-
- src = bitmap->data->chunk[0].data;
-
- if (want_original) {
- format = spice_bitmap_format_to_pixman(bitmap->format, canvas->format);
- } else {
- format = canvas_get_target_format(canvas,
- bitmap->format == SPICE_BITMAP_FMT_RGBA);
- }
-
- image = surface_create(
-#ifdef WIN32
- canvas->dc,
-#endif
- format,
- bitmap->x, bitmap->y, FALSE);
- if (image == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- spice_bitmap_convert_to_pixman(format, image,
- bitmap->format,
- bitmap->flags,
- bitmap->x, bitmap->y,
- src, bitmap->stride,
- canvas->format, palette);
- return image;
-}
-
-
-#ifdef SW_CANVAS_CACHE
-
-static inline SpicePalette *canvas_get_palette(CanvasBase *canvas, SpicePalette *base_palette, uint64_t palette_id, uint8_t flags)
-{
- SpicePalette *palette;
-
- if (flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE) {
- palette = canvas->palette_cache->ops->get(canvas->palette_cache, palette_id);
- } else {
- palette = base_palette;
- if (palette != NULL && flags & SPICE_BITMAP_FLAGS_PAL_CACHE_ME) {
- canvas->palette_cache->ops->put(canvas->palette_cache, palette);
- }
- }
- return palette;
-}
-
-static inline SpicePalette *canvas_get_localized_palette(CanvasBase *canvas, SpicePalette *base_palette, uint64_t palette_id, uint8_t flags, int *free_palette)
-{
- SpicePalette *palette = canvas_get_palette(canvas, base_palette, palette_id, flags);
- SpicePalette *copy;
- uint32_t *now, *end;
- size_t size;
-
- if (canvas->format == SPICE_SURFACE_FMT_32_xRGB ||
- canvas->format == SPICE_SURFACE_FMT_32_ARGB) {
- return palette;
- }
-
- size = sizeof(SpicePalette) + palette->num_ents * 4;
- copy = (SpicePalette *)spice_malloc(size);
- memcpy(copy, palette, size);
-
- switch (canvas->format) {
- case SPICE_SURFACE_FMT_32_xRGB:
- case SPICE_SURFACE_FMT_32_ARGB:
- /* Won't happen */
- break;
- case SPICE_SURFACE_FMT_16_555:
- now = copy->ents;
- end = now + copy->num_ents;
- for (; now < end; now++) {
- *now = canvas_16bpp_to_32bpp(*now);
- }
- break;
- case SPICE_SURFACE_FMT_16_565:
- default:
- PANIC("Unsupported palette depth");
- }
- *free_palette = TRUE;
- return copy;
-}
-
-static pixman_image_t *canvas_get_lz(CanvasBase *canvas, SpiceImage *image, int invers,
- int want_original)
-{
- LzData *lz_data = &canvas->lz_data;
- uint8_t *comp_buf = NULL;
- int comp_size;
- uint8_t *decomp_buf = NULL;
- uint8_t *src;
- pixman_format_code_t pixman_format;
- LzImageType type, as_type;
- SpicePalette *palette;
- int n_comp_pixels;
- int width;
- int height;
- int top_down;
- int stride;
- int free_palette;
-
- if (setjmp(lz_data->jmp_env)) {
- free(decomp_buf);
- CANVAS_ERROR("lz error, %s", lz_data->message_buf);
- }
-
- free_palette = FALSE;
- if (image->descriptor.type == SPICE_IMAGE_TYPE_LZ_RGB) {
- ASSERT(image->u.lz_rgb.data->num_chunks == 1); /* TODO: Handle chunks */
- comp_buf = image->u.lz_rgb.data->chunk[0].data;
- comp_size = image->u.lz_rgb.data->chunk[0].len;
- palette = NULL;
- } else if (image->descriptor.type == SPICE_IMAGE_TYPE_LZ_PLT) {
- ASSERT(image->u.lz_plt.data->num_chunks == 1); /* TODO: Handle chunks */
- comp_buf = image->u.lz_plt.data->chunk[0].data;
- comp_size = image->u.lz_plt.data->chunk[0].len;
- palette = canvas_get_localized_palette(canvas, image->u.lz_plt.palette, image->u.lz_plt.palette_id, image->u.lz_plt.flags, &free_palette);
- } 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:
- as_type = LZ_IMAGE_TYPE_RGBA;
- pixman_format = PIXMAN_a8r8g8b8;
- break;
- case LZ_IMAGE_TYPE_RGB32:
- case LZ_IMAGE_TYPE_RGB24:
- 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:
- as_type = LZ_IMAGE_TYPE_RGB32;
- pixman_format = PIXMAN_x8r8g8b8;
- break;
- case LZ_IMAGE_TYPE_RGB16:
- if (!want_original &&
- (canvas->format == SPICE_SURFACE_FMT_32_xRGB ||
- canvas->format == SPICE_SURFACE_FMT_32_ARGB)) {
- as_type = LZ_IMAGE_TYPE_RGB32;
- pixman_format = PIXMAN_x8r8g8b8;
- } else {
- as_type = LZ_IMAGE_TYPE_RGB16;
- pixman_format = PIXMAN_x1r5g5b5;
- }
- break;
- default:
- CANVAS_ERROR("unexpected LZ image type");
- }
-
- ASSERT((unsigned)width == image->descriptor.width);
- ASSERT((unsigned)height == image->descriptor.height);
-
- ASSERT((image->descriptor.type == SPICE_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, pixman_format,
- width, height, n_comp_pixels, top_down);
-
- src = (uint8_t *)pixman_image_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, as_type, 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 ^= 0xffffffff;
- }
- }
- }
-
- if (free_palette) {
- free(palette);
- }
-
- return lz_data->decode_data.out_surface;
-}
-
-static pixman_image_t *canvas_get_glz_rgb_common(CanvasBase *canvas, uint8_t *data,
- int want_original)
-{
- if (canvas->glz_data.decoder == NULL) {
- CANVAS_ERROR("glz not supported");
- }
-
- canvas->glz_data.decoder->ops->decode(canvas->glz_data.decoder,
- 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);
-}
-
-// don't handle plts since bitmaps with plt can be decoded globally to RGB32 (because
-// same byte sequence can be transformed to different RGB pixels by different plts)
-static pixman_image_t *canvas_get_glz(CanvasBase *canvas, SpiceImage *image,
- int want_original)
-{
- ASSERT(image->descriptor.type == SPICE_IMAGE_TYPE_GLZ_RGB);
-#ifdef WIN32
- canvas->glz_data.decode_data.dc = canvas->dc;
-#endif
-
- ASSERT(image->u.lz_rgb.data->num_chunks == 1); /* TODO: Handle chunks */
- return canvas_get_glz_rgb_common(canvas, image->u.lz_rgb.data->chunk[0].data, want_original);
-}
-
-static pixman_image_t *canvas_get_zlib_glz_rgb(CanvasBase *canvas, SpiceImage *image,
- int want_original)
-{
- uint8_t *glz_data;
- pixman_image_t *surface;
-
- if (canvas->zlib == NULL) {
- CANVAS_ERROR("zlib not supported");
- }
-
- ASSERT(image->u.zlib_glz.data->num_chunks == 1); /* TODO: Handle chunks */
- glz_data = (uint8_t*)spice_malloc(image->u.zlib_glz.glz_data_size);
- canvas->zlib->ops->decode(canvas->zlib, image->u.zlib_glz.data->chunk[0].data,
- image->u.zlib_glz.data->chunk[0].len,
- glz_data, image->u.zlib_glz.glz_data_size);
- surface = canvas_get_glz_rgb_common(canvas, glz_data, want_original);
- free(glz_data);
- return surface;
-}
-
-//#define DEBUG_DUMP_BITMAP
-
-#ifdef DEBUG_DUMP_BITMAP
-static void dump_bitmap(SpiceBitmap *bitmap, SpicePalette *palette)
-{
- uint8_t* data = (uint8_t *)SPICE_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 pixman_image_t *canvas_get_bits(CanvasBase *canvas, SpiceBitmap *bitmap,
- int want_original)
-{
- pixman_image_t* surface;
- SpicePalette *palette;
-
- palette = canvas_get_palette(canvas, bitmap->palette, bitmap->palette_id, bitmap->flags);
-#ifdef DEBUG_DUMP_BITMAP
- if (palette) {
- dump_bitmap(bitmap, palette);
- }
-#endif
-
- surface = canvas_bitmap_to_surface(canvas, bitmap, palette, want_original);
-
- if (palette && (bitmap->flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE)) {
- canvas->palette_cache->ops->release(canvas->palette_cache, palette);
- }
-
- return surface;
-}
-
-#else
-
-
-static pixman_image_t *canvas_get_bits(CanvasBase *canvas, SpiceBitmap *bitmap,
- int want_original)
-{
- SpicePalette *palette;
-
- if (!bitmap->palette) {
- return canvas_bitmap_to_surface(canvas, bitmap, NULL, want_original);
- }
- palette = (SpicePalette *)SPICE_GET_ADDRESS(bitmap->palette);
- return canvas_bitmap_to_surface(canvas, bitmap, palette, want_original);
-}
-
-#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(pixman_image_t *surface, int cache)
-{
- static uint32_t file_id = 0;
- int i, j;
- char file_str[200];
- int depth = pixman_image_get_depth(surface);
-
- if (depth != 24 && depth != 32) {
- return;
- }
-
- uint8_t *data = (uint8_t *)pixman_image_get_data(surface);
- int width = pixman_image_get_width(surface);
- int height = pixman_image_get_height(surface);
- int stride = pixman_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
-
-static SpiceCanvas *canvas_get_surface_internal(CanvasBase *canvas, SpiceImage *image)
-{
- if (image->descriptor.type == SPICE_IMAGE_TYPE_SURFACE) {
- SpiceSurface *surface = &image->u.surface;
- return canvas->surfaces->ops->get(canvas->surfaces, surface->surface_id);
- }
- return NULL;
-}
-
-static SpiceCanvas *canvas_get_surface_mask_internal(CanvasBase *canvas, SpiceImage *image)
-{
- if (image->descriptor.type == SPICE_IMAGE_TYPE_SURFACE) {
- SpiceSurface *surface = &image->u.surface;
- return canvas->surfaces->ops->get(canvas->surfaces, surface->surface_id);
- }
- return NULL;
-}
-
-#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
-
-//#define DEBUG_LZ
-
-/* If real get is FALSE, then only do whatever is needed but don't return an image. For instance,
- * if we need to read it to cache it we do.
- *
- * This generally converts the image to the right type for the canvas.
- * However, if want_original is set the real source format is returned, and
- * you have to be able to handle any image format. This is useful to avoid
- * e.g. losing alpha when blending a argb32 image on a rgb16 surface.
- */
-static pixman_image_t *canvas_get_image_internal(CanvasBase *canvas, SpiceImage *image,
- int want_original, int real_get)
-{
- SpiceImageDescriptor *descriptor = &image->descriptor;
- pixman_image_t *surface, *converted;
- pixman_format_code_t wanted_format, surface_format;
- int saved_want_original;
-#ifdef DEBUG_LZ
- LOG_DEBUG("canvas_get_image image type: " << (int)descriptor->type);
-#endif
-
- /* When touching, only really allocate if we need to cache, or
- * if we're loading a GLZ stream (since those need inter-thread communication
- * to happen which breaks if we don't. */
- if (!real_get &&
- !(descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME) &&
-#ifdef SW_CANVAS_CACHE
- !(descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME) &&
-#endif
- (descriptor->type != SPICE_IMAGE_TYPE_GLZ_RGB) &&
- (descriptor->type != SPICE_IMAGE_TYPE_ZLIB_GLZ_RGB)) {
- return NULL;
- }
-
- saved_want_original = want_original;
- if (descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME
-#ifdef SW_CANVAS_CACHE
- || descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME
-#endif
- ) {
- want_original = TRUE;
- }
-
- switch (descriptor->type) {
- case SPICE_IMAGE_TYPE_QUIC: {
- surface = canvas_get_quic(canvas, image, 0, want_original);
- break;
- }
-#if defined(SW_CANVAS_CACHE)
- case SPICE_IMAGE_TYPE_LZ_PLT: {
- surface = canvas_get_lz(canvas, image, 0, want_original);
- break;
- }
- case SPICE_IMAGE_TYPE_LZ_RGB: {
- surface = canvas_get_lz(canvas, image, 0, want_original);
- break;
- }
-#endif
- case SPICE_IMAGE_TYPE_JPEG: {
- surface = canvas_get_jpeg(canvas, image, 0);
- break;
- }
- case SPICE_IMAGE_TYPE_JPEG_ALPHA: {
- surface = canvas_get_jpeg_alpha(canvas, image, 0);
- break;
- }
-#if defined(SW_CANVAS_CACHE)
- case SPICE_IMAGE_TYPE_GLZ_RGB: {
- surface = canvas_get_glz(canvas, image, want_original);
- break;
- }
- case SPICE_IMAGE_TYPE_ZLIB_GLZ_RGB: {
- surface = canvas_get_zlib_glz_rgb(canvas, image, want_original);
- break;
- }
-#endif
- case SPICE_IMAGE_TYPE_FROM_CACHE:
- surface = canvas->bits_cache->ops->get(canvas->bits_cache, descriptor->id);
- break;
-#ifdef SW_CANVAS_CACHE
- case SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS:
- surface = canvas->bits_cache->ops->get_lossless(canvas->bits_cache, descriptor->id);
- break;
-#endif
- case SPICE_IMAGE_TYPE_BITMAP: {
- surface = canvas_get_bits(canvas, &image->u.bitmap, want_original);
- break;
- }
- default:
- CANVAS_ERROR("invalid image type");
- }
-
- surface_format = spice_pixman_image_get_format(surface);
-
- if (descriptor->flags & SPICE_IMAGE_FLAGS_HIGH_BITS_SET &&
- descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE &&
-#ifdef SW_CANVAS_CACHE
- descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS &&
-#endif
- surface_format == PIXMAN_x8r8g8b8) {
- spice_pixman_fill_rect_rop(surface,
- 0, 0,
- pixman_image_get_width(surface),
- pixman_image_get_height(surface),
- 0xff000000U, SPICE_ROP_OR);
- }
-
- if (descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME &&
-#ifdef SW_CANVAS_CACHE
- descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS &&
-#endif
- descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE ) {
-#ifdef SW_CANVAS_CACHE
- if (!IS_IMAGE_LOSSY(descriptor)) {
- canvas->bits_cache->ops->put(canvas->bits_cache, descriptor->id, surface);
- } else {
- canvas->bits_cache->ops->put_lossy(canvas->bits_cache, descriptor->id, surface);
- }
-#else
- canvas->bits_cache->ops->put(canvas->bits_cache, descriptor->id, surface);
-#endif
-#ifdef DEBUG_DUMP_SURFACE
- dump_surface(surface, 1);
-#endif
-#ifdef SW_CANVAS_CACHE
- } else if (descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME) {
- if (IS_IMAGE_LOSSY(descriptor)) {
- CANVAS_ERROR("invalid cache replace request: the image is lossy");
- }
- canvas->bits_cache->ops->replace_lossy(canvas->bits_cache, descriptor->id, surface);
-#ifdef DEBUG_DUMP_SURFACE
- dump_surface(surface, 1);
-#endif
-#endif
-#ifdef DEBUG_DUMP_SURFACE
- } else if (descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE
-#ifdef SW_CANVAS_CACHE
- && descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS
-#endif
- ) {
-
- dump_surface(surface, 0);
-#endif
- }
-
- if (!real_get) {
- pixman_image_unref(surface);
- return NULL;
- }
-
- if (!saved_want_original) {
- /* Conversion to canvas format was requested, but maybe it didn't
- happen above (due to save/load to cache for instance, or
- maybe the reader didn't support conversion).
- If so we convert here. */
-
- wanted_format = canvas_get_target_format(canvas,
- surface_format == PIXMAN_a8r8g8b8);
-
- if (surface_format != wanted_format) {
- converted = surface_create(
-#ifdef WIN32
- canvas->dc,
-#endif
- wanted_format,
- pixman_image_get_width(surface),
- pixman_image_get_height(surface),
- TRUE);
- pixman_image_composite32 (PIXMAN_OP_SRC,
- surface, NULL, converted,
- 0, 0,
- 0, 0,
- 0, 0,
- pixman_image_get_width(surface),
- pixman_image_get_height(surface));
- pixman_image_unref (surface);
- surface = converted;
- }
- }
-
- return surface;
-}
-
-#else
-
-static pixman_image_t *canvas_get_image_internal(CanvasBase *canvas, SpiceImage *image,
- int want_original, int real_get)
-{
- SpiceImageDescriptor *descriptor = &image->descriptor;
- pixman_format_code_t format;
-
- /* When touching, never load image. */
- if (!real_get) {
- return NULL;
- }
-
- switch (descriptor->type) {
- case SPICE_IMAGE_TYPE_QUIC: {
- return canvas_get_quic(canvas, image, 0);
- }
- case SPICE_IMAGE_TYPE_BITMAP: {
- return canvas_get_bits(canvas, &image->u.bitmap, want_original, &format);
- }
- default:
- CANVAS_ERROR("invalid image type");
- }
-}
-
-#endif
-
-static SpiceCanvas *canvas_get_surface_mask(CanvasBase *canvas, SpiceImage *image)
-{
- return canvas_get_surface_mask_internal(canvas, image);
-}
-
-static SpiceCanvas *canvas_get_surface(CanvasBase *canvas, SpiceImage *image)
-{
- return canvas_get_surface_internal(canvas, image);
-}
-
-static pixman_image_t *canvas_get_image(CanvasBase *canvas, SpiceImage *image,
- int want_original)
-{
- return canvas_get_image_internal(canvas, image, want_original, TRUE);
-}
-
-static void canvas_touch_image(CanvasBase *canvas, SpiceImage *image)
-{
- canvas_get_image_internal(canvas, image, TRUE, FALSE);
-}
-
-static pixman_image_t* canvas_get_image_from_self(SpiceCanvas *canvas,
- int x, int y,
- int32_t width, int32_t height)
-{
- CanvasBase *canvas_base = (CanvasBase *)canvas;
- pixman_image_t *surface;
- uint8_t *dest;
- int dest_stride;
- SpiceRect area;
-
- surface = pixman_image_create_bits(spice_surface_format_to_pixman (canvas_base->format),
- width, height, NULL, 0);
- if (surface == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- dest = (uint8_t *)pixman_image_get_data(surface);
- dest_stride = pixman_image_get_stride(surface);
-
- area.left = x;
- area.top = y;
- area.right = x + width;
- area.bottom = y + height;
-
- canvas->ops->read_bits(canvas, dest, dest_stride, &area);
-
- return surface;
-}
-
-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 pixman_image_t *canvas_get_bitmap_mask(CanvasBase *canvas, SpiceBitmap* bitmap, int invers)
-{
- pixman_image_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
- PIXMAN_a1, bitmap->x, bitmap->y, TRUE);
- if (surface == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- spice_chunks_linearize(bitmap->data);
- src_line = bitmap->data->chunk[0].data;
- src_stride = bitmap->stride;
- end_line = src_line + (bitmap->y * src_stride);
- line_size = SPICE_ALIGN(bitmap->x, 8) >> 3;
-
- dest_stride = pixman_image_get_stride(surface);
- dest_line = (uint8_t *)pixman_image_get_data(surface);
-#if defined(GL_CANVAS)
- if ((bitmap->flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
-#else
- if (!(bitmap->flags & SPICE_BITMAP_FLAGS_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 SPICE_BITMAP_FMT_1BIT_BE:
-#else
- case SPICE_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 SPICE_BITMAP_FMT_1BIT_LE:
-#else
- case SPICE_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:
- pixman_image_unref(surface);
- surface = NULL;
- CANVAS_ERROR("invalid bitmap format");
- }
- } else {
- switch (bitmap->format) {
-#if defined(GL_CANVAS) || defined(GDI_CANVAS)
- case SPICE_BITMAP_FMT_1BIT_BE:
-#else
- case SPICE_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 SPICE_BITMAP_FMT_1BIT_LE:
-#else
- case SPICE_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:
- pixman_image_unref(surface);
- surface = NULL;
- CANVAS_ERROR("invalid bitmap format");
- }
- }
- return surface;
-}
-
-static inline pixman_image_t *canvas_A1_invers(pixman_image_t *src_surf)
-{
- int width = pixman_image_get_width(src_surf);
- int height = pixman_image_get_height(src_surf);
- pixman_image_t * invers;
- uint8_t *src_line, *end_line, *dest_line;
- int src_stride, line_size, dest_stride;
-
- ASSERT(pixman_image_get_depth(src_surf) == 1);
-
- invers = pixman_image_create_bits(PIXMAN_a1, width, height, NULL, 0);
- if (invers == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- src_line = (uint8_t *)pixman_image_get_data(src_surf);
- src_stride = pixman_image_get_stride(src_surf);
- end_line = src_line + (height * src_stride);
- line_size = SPICE_ALIGN(width, 8) >> 3;
- dest_line = (uint8_t *)pixman_image_get_data(invers);
- dest_stride = pixman_image_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 pixman_image_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask, int *needs_invert_out)
-{
- SpiceImage *image;
- pixman_image_t *surface;
- int need_invers;
- int is_invers;
- int cache_me;
-
- if (needs_invert_out) {
- *needs_invert_out = 0;
- }
-
- image = mask->bitmap;
- need_invers = mask->flags & SPICE_MASK_FLAGS_INVERS;
-
-#ifdef SW_CANVAS_CACHE
- cache_me = image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME;
-#else
- cache_me = 0;
-#endif
-
- switch (image->descriptor.type) {
- case SPICE_IMAGE_TYPE_BITMAP: {
- is_invers = need_invers && !cache_me;
- surface = canvas_get_bitmap_mask(canvas, &image->u.bitmap, is_invers);
- break;
- }
-#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
- case SPICE_IMAGE_TYPE_FROM_CACHE:
- surface = canvas->bits_cache->ops->get(canvas->bits_cache, image->descriptor.id);
- is_invers = 0;
- break;
-#endif
-#ifdef SW_CANVAS_CACHE
- case SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS:
- surface = canvas->bits_cache->ops->get_lossless(canvas->bits_cache, image->descriptor.id);
- is_invers = 0;
- break;
-#endif
- default:
- CANVAS_ERROR("invalid image type");
- }
-
-#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
- if (cache_me) {
- canvas->bits_cache->ops->put(canvas->bits_cache, image->descriptor.id, surface);
- }
-
- if (need_invers && !is_invers) { // surface is in cache
- if (needs_invert_out != NULL) {
- *needs_invert_out = TRUE;
- } else {
- pixman_image_t *inv_surf;
- inv_surf = canvas_A1_invers(surface);
- pixman_image_unref(surface);
- surface = inv_surf;
- }
- }
-#endif
- return surface;
-}
-
-static inline void canvas_raster_glyph_box(const SpiceRasterGlyph *glyph, SpiceRect *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(SpiceRasterGlyph *glyph, int bpp, uint8_t *dest, int dest_stride,
- SpiceRect *bounds)
-{
- SpiceRect glyph_box;
- uint8_t *src;
- int lines;
- int width;
-
- //todo: support SPICE_STRING_FLAGS_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 = SPICE_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 = SPICE_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 pixman_image_t *canvas_get_str_mask(CanvasBase *canvas, SpiceString *str, int bpp, SpicePoint *pos)
-{
- SpiceRasterGlyph *glyph;
- SpiceRect bounds;
- pixman_image_t *str_mask;
- uint8_t *dest;
- int dest_stride;
- int i;
-
- ASSERT(str->length > 0);
-
- glyph = str->glyphs[0];
- canvas_raster_glyph_box(glyph, &bounds);
-
- for (i = 1; i < str->length; i++) {
- SpiceRect glyph_box;
-
- canvas_raster_glyph_box(str->glyphs[i], &glyph_box);
- rect_union(&bounds, &glyph_box);
- }
-
- str_mask = pixman_image_create_bits((bpp == 1) ? PIXMAN_a1 : PIXMAN_a8,
- bounds.right - bounds.left,
- bounds.bottom - bounds.top, NULL, 0);
- if (str_mask == NULL) {
- CANVAS_ERROR("create surface failed");
- }
- dest = (uint8_t *)pixman_image_get_data(str_mask);
- dest_stride = pixman_image_get_stride(str_mask);
- for (i = 0; i < str->length; i++) {
- glyph = str->glyphs[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
- }
-
- pos->x = bounds.left;
- pos->y = bounds.top;
- return str_mask;
-}
-
-static pixman_image_t *canvas_scale_surface(pixman_image_t *src, const SpiceRect *src_area, int width,
- int height, int scale_mode)
-{
- pixman_image_t *surface;
- pixman_transform_t transform;
- double sx, sy;
-
- surface = pixman_image_create_bits(spice_pixman_image_get_format (src),
- width, height, NULL, 0);
- if (surface == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- sx = (double)(src_area->right - src_area->left) / width;
- sy = (double)(src_area->bottom - src_area->top) / height;
-
- pixman_transform_init_scale(&transform, pixman_double_to_fixed(sx), pixman_double_to_fixed(sy));
-
- pixman_image_set_transform (src, &transform);
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
- ASSERT(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE || scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
- pixman_image_set_filter(src,
- (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?PIXMAN_FILTER_NEAREST : PIXMAN_FILTER_GOOD,
- NULL, 0);
-
- pixman_image_composite32(PIXMAN_OP_SRC,
- src, NULL, surface,
- ROUND(src_area->left / sx), ROUND (src_area->top / sy),
- 0, 0, /* mask */
- 0, 0, /* dst */
- width, height);
-
- pixman_transform_init_identity(&transform);
- pixman_image_set_transform(src, &transform);
-
- 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 spice_malloc(size);
-}
-
-static void quic_usr_free(QuicUsrContext *usr, void *ptr)
-{
- free(ptr);
-}
-
-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 spice_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;
-}
-
-static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
-{
- QuicData *quic_data = (QuicData *)usr;
-
- if (quic_data->current_chunk == quic_data->chunks->num_chunks -1) {
- return 0;
- }
- quic_data->current_chunk++;
-
- *io_ptr = (uint32_t *)quic_data->chunks->chunk[quic_data->current_chunk].data;
- return quic_data->chunks->chunk[quic_data->current_chunk].len >> 2;
-}
-
-
-static int quic_usr_more_lines(QuicUsrContext *usr, uint8_t **lines)
-{
- return 0;
-}
-
-static void canvas_base_destroy(CanvasBase *canvas)
-{
- quic_destroy(canvas->quic_data.quic);
- lz_destroy(canvas->lz_data.lz);
-#ifdef GDI_CANVAS
- DeleteDC(canvas->dc);
-#endif
-
- if (canvas->usr_data && canvas->usr_data_destroy) {
- canvas->usr_data_destroy (canvas->usr_data);
- canvas->usr_data = NULL;
- }
-}
-
-/* This is kind of lame, but it protects against multiple
- instances of these functions. We really should stop including
- canvas_base.c and build it separately instead */
-#ifdef CANVAS_SINGLE_INSTANCE
-
-void spice_canvas_set_usr_data(SpiceCanvas *spice_canvas,
- void *data,
- spice_destroy_fn_t destroy_fn)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- if (canvas->usr_data && canvas->usr_data_destroy) {
- canvas->usr_data_destroy (canvas->usr_data);
- }
- canvas->usr_data = data;
- canvas->usr_data_destroy = destroy_fn;
-}
-
-void *spice_canvas_get_usr_data(SpiceCanvas *spice_canvas)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- return canvas->usr_data;
-}
-#endif
-
-
-static void canvas_clip_pixman(CanvasBase *canvas,
- pixman_region32_t *dest_region,
- SpiceClip *clip)
-{
- pixman_region32_intersect(dest_region, dest_region, &canvas->canvas_region);
-
- switch (clip->type) {
- case SPICE_CLIP_TYPE_NONE:
- break;
- case SPICE_CLIP_TYPE_RECTS: {
- uint32_t n = clip->rects->num_rects;
- SpiceRect *now = clip->rects->rects;
-
- pixman_region32_t clip;
-
- if (spice_pixman_region32_init_rects(&clip, now, n)) {
- pixman_region32_intersect(dest_region, dest_region, &clip);
- pixman_region32_fini(&clip);
- }
-
- break;
- }
- default:
- CANVAS_ERROR("invalid clip type");
- }
-}
-
-static void canvas_mask_pixman(CanvasBase *canvas,
- pixman_region32_t *dest_region,
- SpiceQMask *mask, int x, int y)
-{
- SpiceCanvas *surface_canvas;
- pixman_image_t *image, *subimage;
- int needs_invert;
- pixman_region32_t mask_region;
- uint32_t *mask_data;
- int mask_x, mask_y;
- int mask_width, mask_height, mask_stride;
- pixman_box32_t extents;
-
- if (!mask->bitmap) {
- return;
- }
-
- surface_canvas = canvas_get_surface_mask(canvas, mask->bitmap);
- if (surface_canvas) {
- needs_invert = mask->flags & SPICE_MASK_FLAGS_INVERS;
- image = surface_canvas->ops->get_image(surface_canvas);
- } else {
- needs_invert = FALSE;
- image = canvas_get_mask(canvas,
- mask,
- &needs_invert);
- }
-
- mask_data = pixman_image_get_data(image);
- mask_width = pixman_image_get_width(image);
- mask_height = pixman_image_get_height(image);
- mask_stride = pixman_image_get_stride(image);
-
- mask_x = mask->pos.x;
- mask_y = mask->pos.y;
-
- /* We need to subset the area of the mask that we turn into a region,
- because a cached mask may be much larger than what is used for
- the clip operation. */
- extents = *pixman_region32_extents(dest_region);
-
- /* convert from destination pixels to mask pixels */
- extents.x1 -= x - mask_x;
- extents.y1 -= y - mask_y;
- extents.x2 -= x - mask_x;
- extents.y2 -= y - mask_y;
-
- /* clip to mask size */
- if (extents.x1 < 0) {
- extents.x1 = 0;
- }
- if (extents.x2 >= mask_width) {
- extents.x2 = mask_width;
- }
- if (extents.x2 < extents.x1) {
- extents.x2 = extents.x1;
- }
- if (extents.y1 < 0) {
- extents.y1 = 0;
- }
- if (extents.y2 >= mask_height) {
- extents.y2 = mask_height;
- }
- if (extents.y2 < extents.y1) {
- extents.y2 = extents.y1;
- }
-
- /* round down X to even 32 pixels (i.e. uint32_t) */
- extents.x1 = extents.x1 & ~(0x1f);
-
- mask_data = (uint32_t *)((uint8_t *)mask_data + mask_stride * extents.y1 + extents.x1 / 32);
- mask_x -= extents.x1;
- mask_y -= extents.y1;
- mask_width = extents.x2 - extents.x1;
- mask_height = extents.y2 - extents.y1;
-
- subimage = pixman_image_create_bits(PIXMAN_a1, mask_width, mask_height,
- mask_data, mask_stride);
- pixman_region32_init_from_image(&mask_region,
- subimage);
- pixman_image_unref(subimage);
-
- if (needs_invert) {
- pixman_box32_t rect;
-
- rect.x1 = rect.y1 = 0;
- rect.x2 = mask_width;
- rect.y2 = mask_height;
-
- pixman_region32_inverse(&mask_region, &mask_region, &rect);
- }
-
- pixman_region32_translate(&mask_region,
- -mask_x + x, -mask_y + y);
-
- pixman_region32_intersect(dest_region, dest_region, &mask_region);
- pixman_region32_fini(&mask_region);
-
- pixman_image_unref(image);
-}
-
-static void draw_brush(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceBrush *brush,
- SpiceROP rop)
-{
- CanvasBase *canvas_base = (CanvasBase *)canvas;
- uint32_t color;
- SpicePattern *pattern;
- pixman_image_t *tile;
- int offset_x, offset_y;
- pixman_box32_t *rects;
- int n_rects;
-
- rects = pixman_region32_rectangles(region, &n_rects);
-
- switch (brush->type) {
- case SPICE_BRUSH_TYPE_SOLID:
- color = brush->u.color;
- if (rop == SPICE_ROP_COPY) {
- canvas->ops->fill_solid_rects(canvas, rects, n_rects, color);
- } else {
- canvas->ops->fill_solid_rects_rop(canvas, rects, n_rects, color, rop);
- }
- break;
- case SPICE_BRUSH_TYPE_PATTERN: {
- SpiceCanvas *surface_canvas;
-
- pattern = &brush->u.pattern;
- offset_x = pattern->pos.x;
- offset_y = pattern->pos.y;
-
- surface_canvas = canvas_get_surface(canvas_base, pattern->pat);
- if (surface_canvas) {
- if (rop == SPICE_ROP_COPY) {
- canvas->ops->fill_tiled_rects_from_surface(canvas, rects, n_rects, surface_canvas,
- offset_x, offset_y);
- } else {
- canvas->ops->fill_tiled_rects_rop_from_surface(canvas, rects, n_rects,
- surface_canvas, offset_x, offset_y,
- rop);
- }
- } else {
- tile = canvas_get_image(canvas_base, pattern->pat, FALSE);
- if (rop == SPICE_ROP_COPY) {
- canvas->ops->fill_tiled_rects(canvas, rects, n_rects, tile, offset_x, offset_y);
- } else {
- canvas->ops->fill_tiled_rects_rop(canvas, rects, n_rects,
- tile, offset_x, offset_y, rop);
- }
- pixman_image_unref(tile);
- }
- break;
- }
- case SPICE_BRUSH_TYPE_NONE:
- /* Still need to do *something* here, because rop could be e.g invert dest */
- canvas->ops->fill_solid_rects_rop(canvas, rects, n_rects, 0, rop);
- break;
- default:
- CANVAS_ERROR("invalid brush type");
- }
-}
-
-/* If we're exiting early we may still have to load an image in case
- it has to be cached or something */
-static void touch_brush(CanvasBase *canvas, SpiceBrush *brush)
-{
- SpicePattern *pattern;
-
- if (brush->type == SPICE_BRUSH_TYPE_PATTERN) {
- pattern = &brush->u.pattern;
- canvas_touch_image(canvas, pattern->pat);
- }
-}
-
-static void canvas_draw_fill(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- SpiceROP rop;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &fill->mask,
- bbox->left, bbox->top);
-
- rop = ropd_descriptor_to_rop(fill->rop_descriptor,
- ROP_INPUT_BRUSH,
- ROP_INPUT_DEST);
-
- if (rop == SPICE_ROP_NOOP || !pixman_region32_not_empty(&dest_region)) {
- touch_brush(canvas, &fill->brush);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- draw_brush(spice_canvas, &dest_region, &fill->brush, rop);
-
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_copy(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- SpiceCanvas *surface_canvas;
- pixman_image_t *src_image;
- SpiceROP rop;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, ©->mask,
- bbox->left, bbox->top);
-
- rop = ropd_descriptor_to_rop(copy->rop_descriptor,
- ROP_INPUT_SRC,
- ROP_INPUT_DEST);
-
- if (rop == SPICE_ROP_NOOP || !pixman_region32_not_empty(&dest_region)) {
- canvas_touch_image(canvas, copy->src_bitmap);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- surface_canvas = canvas_get_surface(canvas, copy->src_bitmap);
- if (surface_canvas) {
- if (rect_is_same_size(bbox, ©->src_area)) {
- if (rop == SPICE_ROP_COPY) {
- spice_canvas->ops->blit_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- bbox->left - copy->src_area.left,
- bbox->top - copy->src_area.top);
- } else {
- spice_canvas->ops->blit_image_rop_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- bbox->left - copy->src_area.left,
- bbox->top - copy->src_area.top,
- rop);
- }
- } else {
- if (rop == SPICE_ROP_COPY) {
- spice_canvas->ops->scale_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- copy->src_area.left,
- copy->src_area.top,
- copy->src_area.right - copy->src_area.left,
- copy->src_area.bottom - copy->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- copy->scale_mode);
- } else {
- spice_canvas->ops->scale_image_rop_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- copy->src_area.left,
- copy->src_area.top,
- copy->src_area.right - copy->src_area.left,
- copy->src_area.bottom - copy->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- copy->scale_mode,
- rop);
- }
- }
- } else {
- src_image = canvas_get_image(canvas, copy->src_bitmap, FALSE);
- if (rect_is_same_size(bbox, ©->src_area)) {
- if (rop == SPICE_ROP_COPY) {
- spice_canvas->ops->blit_image(spice_canvas, &dest_region,
- src_image,
- bbox->left - copy->src_area.left,
- bbox->top - copy->src_area.top);
- } else {
- spice_canvas->ops->blit_image_rop(spice_canvas, &dest_region,
- src_image,
- bbox->left - copy->src_area.left,
- bbox->top - copy->src_area.top,
- rop);
- }
- } else {
- if (rop == SPICE_ROP_COPY) {
- spice_canvas->ops->scale_image(spice_canvas, &dest_region,
- src_image,
- copy->src_area.left,
- copy->src_area.top,
- copy->src_area.right - copy->src_area.left,
- copy->src_area.bottom - copy->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- copy->scale_mode);
- } else {
- spice_canvas->ops->scale_image_rop(spice_canvas, &dest_region,
- src_image,
- copy->src_area.left,
- copy->src_area.top,
- copy->src_area.right - copy->src_area.left,
- copy->src_area.bottom - copy->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- copy->scale_mode,
- rop);
- }
- }
- pixman_image_unref(src_image);
- }
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_transparent(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- SpiceCanvas *surface_canvas;
- pixman_image_t *src_image;
- pixman_region32_t dest_region;
- uint32_t transparent_color;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
-
- if (pixman_region32_n_rects (&dest_region) == 0) {
- canvas_touch_image(canvas, transparent->src_bitmap);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- switch (canvas->format) {
- case SPICE_SURFACE_FMT_32_xRGB:
- case SPICE_SURFACE_FMT_32_ARGB:
- transparent_color = transparent->true_color;
- break;
- case SPICE_SURFACE_FMT_16_555:
- transparent_color = rgb_32_to_16_555(transparent->true_color);
- break;
- case SPICE_SURFACE_FMT_16_565:
- transparent_color = rgb_32_to_16_565(transparent->true_color);
- break;
- default:
- transparent_color = 0;
- }
-
- surface_canvas = canvas_get_surface(canvas, transparent->src_bitmap);
- if (surface_canvas) {
- if (rect_is_same_size(bbox, &transparent->src_area)) {
- spice_canvas->ops->colorkey_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- bbox->left - transparent->src_area.left,
- bbox->top - transparent->src_area.top,
- transparent_color);
- } else {
- spice_canvas->ops->colorkey_scale_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- transparent->src_area.left,
- transparent->src_area.top,
- transparent->src_area.right - transparent->src_area.left,
- transparent->src_area.bottom - transparent->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- transparent_color);
- }
- } else {
- src_image = canvas_get_image(canvas, transparent->src_bitmap, FALSE);
- if (rect_is_same_size(bbox, &transparent->src_area)) {
- spice_canvas->ops->colorkey_image(spice_canvas, &dest_region,
- src_image,
- bbox->left - transparent->src_area.left,
- bbox->top - transparent->src_area.top,
- transparent_color);
- } else {
- spice_canvas->ops->colorkey_scale_image(spice_canvas, &dest_region,
- src_image,
- transparent->src_area.left,
- transparent->src_area.top,
- transparent->src_area.right - transparent->src_area.left,
- transparent->src_area.bottom - transparent->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- transparent_color);
- }
- pixman_image_unref(src_image);
- }
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_alpha_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlend* alpha_blend)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- SpiceCanvas *surface_canvas;
- pixman_image_t *src_image;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
-
- if (alpha_blend->alpha == 0 ||
- !pixman_region32_not_empty(&dest_region)) {
- canvas_touch_image(canvas, alpha_blend->src_bitmap);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- surface_canvas = canvas_get_surface(canvas, alpha_blend->src_bitmap);
- if (surface_canvas) {
- if (rect_is_same_size(bbox, &alpha_blend->src_area)) {
- spice_canvas->ops->blend_image_from_surface(spice_canvas, &dest_region,
- alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_DEST_HAS_ALPHA,
- surface_canvas,
- alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_SRC_SURFACE_HAS_ALPHA,
- alpha_blend->src_area.left,
- alpha_blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- alpha_blend->alpha);
- } else {
- spice_canvas->ops->blend_scale_image_from_surface(spice_canvas, &dest_region,
- alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_DEST_HAS_ALPHA,
- surface_canvas,
- alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_SRC_SURFACE_HAS_ALPHA,
- alpha_blend->src_area.left,
- alpha_blend->src_area.top,
- alpha_blend->src_area.right - alpha_blend->src_area.left,
- alpha_blend->src_area.bottom - alpha_blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- SPICE_IMAGE_SCALE_MODE_NEAREST,
- alpha_blend->alpha);
- }
- } else {
- src_image = canvas_get_image(canvas, alpha_blend->src_bitmap, TRUE);
- if (rect_is_same_size(bbox, &alpha_blend->src_area)) {
- spice_canvas->ops->blend_image(spice_canvas, &dest_region,
- alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_DEST_HAS_ALPHA,
- src_image,
- alpha_blend->src_area.left,
- alpha_blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- alpha_blend->alpha);
- } else {
- spice_canvas->ops->blend_scale_image(spice_canvas, &dest_region,
- alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_DEST_HAS_ALPHA,
- src_image,
- alpha_blend->src_area.left,
- alpha_blend->src_area.top,
- alpha_blend->src_area.right - alpha_blend->src_area.left,
- alpha_blend->src_area.bottom - alpha_blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- SPICE_IMAGE_SCALE_MODE_NEAREST,
- alpha_blend->alpha);
- }
-
- pixman_image_unref(src_image);
- }
-
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_opaque(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_image_t *src_image;
- pixman_region32_t dest_region;
- SpiceCanvas *surface_canvas;
- SpiceROP rop;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &opaque->mask,
- bbox->left, bbox->top);
-
- rop = ropd_descriptor_to_rop(opaque->rop_descriptor,
- ROP_INPUT_BRUSH,
- ROP_INPUT_SRC);
-
- if (rop == SPICE_ROP_NOOP || !pixman_region32_not_empty(&dest_region)) {
- canvas_touch_image(canvas, opaque->src_bitmap);
- touch_brush(canvas, &opaque->brush);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- surface_canvas = canvas_get_surface(canvas, opaque->src_bitmap);
- if (surface_canvas) {
- if (rect_is_same_size(bbox, &opaque->src_area)) {
- spice_canvas->ops->blit_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- bbox->left - opaque->src_area.left,
- bbox->top - opaque->src_area.top);
- } else {
- spice_canvas->ops->scale_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- opaque->src_area.left,
- opaque->src_area.top,
- opaque->src_area.right - opaque->src_area.left,
- opaque->src_area.bottom - opaque->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- opaque->scale_mode);
- }
- } else {
- src_image = canvas_get_image(canvas, opaque->src_bitmap, FALSE);
-
- if (rect_is_same_size(bbox, &opaque->src_area)) {
- spice_canvas->ops->blit_image(spice_canvas, &dest_region,
- src_image,
- bbox->left - opaque->src_area.left,
- bbox->top - opaque->src_area.top);
- } else {
- spice_canvas->ops->scale_image(spice_canvas, &dest_region,
- src_image,
- opaque->src_area.left,
- opaque->src_area.top,
- opaque->src_area.right - opaque->src_area.left,
- opaque->src_area.bottom - opaque->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- opaque->scale_mode);
- }
- pixman_image_unref(src_image);
- }
-
- draw_brush(spice_canvas, &dest_region, &opaque->brush, rop);
-
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- SpiceCanvas *surface_canvas;
- pixman_image_t *src_image;
- pixman_region32_t dest_region;
- SpiceROP rop;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &blend->mask,
- bbox->left, bbox->top);
-
- rop = ropd_descriptor_to_rop(blend->rop_descriptor,
- ROP_INPUT_SRC,
- ROP_INPUT_DEST);
-
- if (rop == SPICE_ROP_NOOP || !pixman_region32_not_empty(&dest_region)) {
- canvas_touch_image(canvas, blend->src_bitmap);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- surface_canvas = canvas_get_surface(canvas, blend->src_bitmap);
- if (surface_canvas) {
- if (rect_is_same_size(bbox, &blend->src_area)) {
- if (rop == SPICE_ROP_COPY)
- spice_canvas->ops->blit_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- bbox->left - blend->src_area.left,
- bbox->top - blend->src_area.top);
- else
- spice_canvas->ops->blit_image_rop_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- bbox->left - blend->src_area.left,
- bbox->top - blend->src_area.top,
- rop);
- } else {
- if (rop == SPICE_ROP_COPY) {
- spice_canvas->ops->scale_image_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- blend->src_area.left,
- blend->src_area.top,
- blend->src_area.right - blend->src_area.left,
- blend->src_area.bottom - blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- blend->scale_mode);
- } else {
- spice_canvas->ops->scale_image_rop_from_surface(spice_canvas, &dest_region,
- surface_canvas,
- blend->src_area.left,
- blend->src_area.top,
- blend->src_area.right - blend->src_area.left,
- blend->src_area.bottom - blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- blend->scale_mode, rop);
- }
- }
- } else {
- src_image = canvas_get_image(canvas, blend->src_bitmap, FALSE);
- if (rect_is_same_size(bbox, &blend->src_area)) {
- if (rop == SPICE_ROP_COPY)
- spice_canvas->ops->blit_image(spice_canvas, &dest_region,
- src_image,
- bbox->left - blend->src_area.left,
- bbox->top - blend->src_area.top);
- else
- spice_canvas->ops->blit_image_rop(spice_canvas, &dest_region,
- src_image,
- bbox->left - blend->src_area.left,
- bbox->top - blend->src_area.top,
- rop);
- } else {
- if (rop == SPICE_ROP_COPY) {
- spice_canvas->ops->scale_image(spice_canvas, &dest_region,
- src_image,
- blend->src_area.left,
- blend->src_area.top,
- blend->src_area.right - blend->src_area.left,
- blend->src_area.bottom - blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- blend->scale_mode);
- } else {
- spice_canvas->ops->scale_image_rop(spice_canvas, &dest_region,
- src_image,
- blend->src_area.left,
- blend->src_area.top,
- blend->src_area.right - blend->src_area.left,
- blend->src_area.bottom - blend->src_area.top,
- bbox->left,
- bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top,
- blend->scale_mode, rop);
- }
- }
- pixman_image_unref(src_image);
- }
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_blackness(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- pixman_box32_t *rects;
- int n_rects;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &blackness->mask,
- bbox->left, bbox->top);
-
- if (!pixman_region32_not_empty(&dest_region)) {
- pixman_region32_fini (&dest_region);
- return;
- }
-
- rects = pixman_region32_rectangles(&dest_region, &n_rects);
-
- spice_canvas->ops->fill_solid_rects(spice_canvas, rects, n_rects, 0x000000);
-
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_whiteness(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- pixman_box32_t *rects;
- int n_rects;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &whiteness->mask,
- bbox->left, bbox->top);
-
- if (!pixman_region32_not_empty(&dest_region)) {
- pixman_region32_fini(&dest_region);
- return;
- }
-
- rects = pixman_region32_rectangles(&dest_region, &n_rects);
- spice_canvas->ops->fill_solid_rects(spice_canvas, rects, n_rects, 0xffffffff);
-
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_draw_invers(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- pixman_box32_t *rects;
- int n_rects;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &invers->mask,
- bbox->left, bbox->top);
-
- if (!pixman_region32_not_empty(&dest_region)) {
- pixman_region32_fini(&dest_region);
- return;
- }
-
- rects = pixman_region32_rectangles(&dest_region, &n_rects);
- spice_canvas->ops->fill_solid_rects_rop(spice_canvas, rects, n_rects, 0x00000000,
- SPICE_ROP_INVERT);
-
- pixman_region32_fini(&dest_region);
-}
-
-typedef struct {
- lineGC base;
- SpiceCanvas *canvas;
- pixman_region32_t dest_region;
- SpiceROP fore_rop;
- SpiceROP back_rop;
- int solid;
- uint32_t color;
- int use_surface_canvas;
- union {
- SpiceCanvas *surface_canvas;
- pixman_image_t *tile;
- };
- int tile_offset_x;
- int tile_offset_y;
-} StrokeGC;
-
-static void stroke_fill_spans(lineGC * pGC,
- int num_spans,
- SpicePoint *points,
- int *widths,
- int sorted,
- int foreground)
-{
- SpiceCanvas *canvas;
- StrokeGC *strokeGC;
- int i;
- SpiceROP rop;
-
- strokeGC = (StrokeGC *)pGC;
- canvas = strokeGC->canvas;
-
- num_spans = spice_canvas_clip_spans(&strokeGC->dest_region,
- points, widths, num_spans,
- points, widths, sorted);
-
- if (foreground) {
- rop = strokeGC->fore_rop;
- } else {
- rop = strokeGC->back_rop;
- }
-
- if (strokeGC->solid) {
- if (rop == SPICE_ROP_COPY) {
- canvas->ops->fill_solid_spans(canvas, points, widths, num_spans,
- strokeGC->color);
- } else {
- for (i = 0; i < num_spans; i++) {
- pixman_box32_t r;
- r.x1 = points[i].x;
- r.y1 = points[i].y;
- r.x2 = points[i].x + widths[i];
- r.y2 = r.y1 + 1;
- canvas->ops->fill_solid_rects_rop(canvas, &r, 1,
- strokeGC->color, rop);
- }
- }
- } else {
- if (rop == SPICE_ROP_COPY) {
- for (i = 0; i < num_spans; i++) {
- pixman_box32_t r;
- r.x1 = points[i].x;
- r.y1 = points[i].y;
- r.x2 = points[i].x + widths[i];
- r.y2 = r.y1 + 1;
- canvas->ops->fill_tiled_rects(canvas, &r, 1,
- strokeGC->tile,
- strokeGC->tile_offset_x,
- strokeGC->tile_offset_y);
- }
- } else {
- for (i = 0; i < num_spans; i++) {
- pixman_box32_t r;
- r.x1 = points[i].x;
- r.y1 = points[i].y;
- r.x2 = points[i].x + widths[i];
- r.y2 = r.y1 + 1;
- canvas->ops->fill_tiled_rects_rop(canvas, &r, 1,
- strokeGC->tile,
- strokeGC->tile_offset_x,
- strokeGC->tile_offset_y, rop);
- }
- }
- }
-}
-
-static void stroke_fill_rects(lineGC * pGC,
- int num_rects,
- pixman_rectangle32_t *rects,
- int foreground)
-{
- SpiceCanvas *canvas;
- pixman_region32_t area;
- pixman_box32_t *boxes;
- StrokeGC *strokeGC;
- SpiceROP rop;
- int i;
- pixman_box32_t *area_rects;
- int n_area_rects;
-
- strokeGC = (StrokeGC *)pGC;
- canvas = strokeGC->canvas;
-
- if (foreground) {
- rop = strokeGC->fore_rop;
- } else {
- rop = strokeGC->back_rop;
- }
-
- /* TODO: We can optimize this for more common cases where
- dest is one rect */
-
- boxes = spice_new(pixman_box32_t, num_rects);
- for (i = 0; i < num_rects; i++) {
- boxes[i].x1 = rects[i].x;
- boxes[i].y1 = rects[i].y;
- boxes[i].x2 = rects[i].x + rects[i].width;
- boxes[i].y2 = rects[i].y + rects[i].height;
- }
- pixman_region32_init_rects(&area, boxes, num_rects);
- pixman_region32_intersect(&area, &area, &strokeGC->dest_region);
- free(boxes);
-
- area_rects = pixman_region32_rectangles(&area, &n_area_rects);
-
- if (strokeGC->solid) {
- if (rop == SPICE_ROP_COPY) {
- canvas->ops->fill_solid_rects(canvas, area_rects, n_area_rects,
- strokeGC->color);
- } else {
- canvas->ops->fill_solid_rects_rop(canvas, area_rects, n_area_rects,
- strokeGC->color, rop);
- }
- } else {
- if (rop == SPICE_ROP_COPY) {
- if (strokeGC->use_surface_canvas) {
- canvas->ops->fill_tiled_rects_from_surface(canvas, area_rects, n_area_rects,
- strokeGC->surface_canvas,
- strokeGC->tile_offset_x,
- strokeGC->tile_offset_y);
- } else {
- canvas->ops->fill_tiled_rects(canvas, area_rects, n_area_rects,
- strokeGC->tile,
- strokeGC->tile_offset_x,
- strokeGC->tile_offset_y);
- }
- } else {
- if (strokeGC->use_surface_canvas) {
- canvas->ops->fill_tiled_rects_rop_from_surface(canvas, area_rects, n_area_rects,
- strokeGC->surface_canvas,
- strokeGC->tile_offset_x,
- strokeGC->tile_offset_y,
- rop);
- } else {
- canvas->ops->fill_tiled_rects_rop(canvas, area_rects, n_area_rects,
- strokeGC->tile,
- strokeGC->tile_offset_x,
- strokeGC->tile_offset_y,
- rop);
- }
- }
- }
-
- pixman_region32_fini(&area);
-}
-
-typedef struct {
- SpicePoint *points;
- int num_points;
- int size;
-} StrokeLines;
-
-static void stroke_lines_init(StrokeLines *lines)
-{
- lines->points = spice_new(SpicePoint, 10);
- lines->size = 10;
- lines->num_points = 0;
-}
-
-static void stroke_lines_free(StrokeLines *lines)
-{
- free(lines->points);
-}
-
-static void stroke_lines_append(StrokeLines *lines,
- int x, int y)
-{
- if (lines->num_points == lines->size) {
- lines->size *= 2;
- lines->points = spice_renew(SpicePoint, lines->points, lines->size);
- }
- lines->points[lines->num_points].x = x;
- lines->points[lines->num_points].y = y;
- lines->num_points++;
-}
-
-static void stroke_lines_append_fix(StrokeLines *lines,
- SpicePointFix *point)
-{
- stroke_lines_append(lines,
- fix_to_int(point->x),
- fix_to_int(point->y));
-}
-
-static inline int64_t dot(SPICE_FIXED28_4 x1,
- SPICE_FIXED28_4 y1,
- SPICE_FIXED28_4 x2,
- SPICE_FIXED28_4 y2)
-{
- return (((int64_t)x1) *((int64_t)x2) +
- ((int64_t)y1) *((int64_t)y2)) >> 4;
-}
-
-static inline int64_t dot2(SPICE_FIXED28_4 x,
- SPICE_FIXED28_4 y)
-{
- return (((int64_t)x) *((int64_t)x) +
- ((int64_t)y) *((int64_t)y)) >> 4;
-}
-
-static void subdivide_bezier(StrokeLines *lines,
- SpicePointFix point0,
- SpicePointFix point1,
- SpicePointFix point2,
- SpicePointFix point3)
-{
- int64_t A2, B2, C2, AB, CB, h1, h2;
-
- A2 = dot2(point1.x - point0.x,
- point1.y - point0.y);
- B2 = dot2(point3.x - point0.x,
- point3.y - point0.y);
- C2 = dot2(point2.x - point3.x,
- point2.y - point3.y);
-
- AB = dot(point1.x - point0.x,
- point1.y - point0.y,
- point3.x - point0.x,
- point3.y - point0.y);
-
- CB = dot(point2.x - point3.x,
- point2.y - point3.y,
- point0.x - point3.x,
- point0.y - point3.y);
-
- h1 = (A2*B2 - AB*AB) >> 3;
- h2 = (C2*B2 - CB*CB) >> 3;
-
- if (h1 < B2 && h2 < B2) {
- /* deviation squared less than half a pixel, use straight line */
- stroke_lines_append_fix(lines, &point3);
- } else {
- SpicePointFix point01, point23, point12, point012, point123, point0123;
-
- point01.x = (point0.x + point1.x) / 2;
- point01.y = (point0.y + point1.y) / 2;
- point12.x = (point1.x + point2.x) / 2;
- point12.y = (point1.y + point2.y) / 2;
- point23.x = (point2.x + point3.x) / 2;
- point23.y = (point2.y + point3.y) / 2;
- point012.x = (point01.x + point12.x) / 2;
- point012.y = (point01.y + point12.y) / 2;
- point123.x = (point12.x + point23.x) / 2;
- point123.y = (point12.y + point23.y) / 2;
- point0123.x = (point012.x + point123.x) / 2;
- point0123.y = (point012.y + point123.y) / 2;
-
- subdivide_bezier(lines, point0, point01, point012, point0123);
- subdivide_bezier(lines, point0123, point123, point23, point3);
- }
-}
-
-static void stroke_lines_append_bezier(StrokeLines *lines,
- SpicePointFix *point1,
- SpicePointFix *point2,
- SpicePointFix *point3)
-{
- SpicePointFix point0;
-
- point0.x = int_to_fix(lines->points[lines->num_points-1].x);
- point0.y = int_to_fix(lines->points[lines->num_points-1].y);
-
- subdivide_bezier(lines, point0, *point1, *point2, *point3);
-}
-
-static void stroke_lines_draw(StrokeLines *lines,
- lineGC *gc,
- int dashed)
-{
- if (lines->num_points != 0) {
- if (dashed) {
- spice_canvas_zero_dash_line(gc, CoordModeOrigin,
- lines->num_points, lines->points);
- } else {
- spice_canvas_zero_line(gc, CoordModeOrigin,
- lines->num_points, lines->points);
- }
- lines->num_points = 0;
- }
-}
-
-
-static void canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox,
- SpiceClip *clip, SpiceStroke *stroke)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- SpiceCanvas *surface_canvas = NULL;
- StrokeGC gc = { { 0 } };
- lineGCOps ops = {
- stroke_fill_spans,
- stroke_fill_rects
- };
- StrokeLines lines;
- unsigned int i;
- int dashed;
-
- pixman_region32_init_rect(&gc.dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &gc.dest_region, clip);
-
- if (!pixman_region32_not_empty(&gc.dest_region)) {
- touch_brush(canvas, &stroke->brush);
- pixman_region32_fini(&gc.dest_region);
- return;
- }
-
- gc.canvas = spice_canvas;
- gc.fore_rop = ropd_descriptor_to_rop(stroke->fore_mode,
- ROP_INPUT_BRUSH,
- ROP_INPUT_DEST);
- gc.back_rop = ropd_descriptor_to_rop(stroke->back_mode,
- ROP_INPUT_BRUSH,
- ROP_INPUT_DEST);
-
- gc.base.width = canvas->width;
- gc.base.height = canvas->height;
- gc.base.alu = gc.fore_rop;
- gc.base.lineWidth = 0;
-
- /* dash */
- gc.base.dashOffset = 0;
- gc.base.dash = NULL;
- gc.base.numInDashList = 0;
- gc.base.lineStyle = LineSolid;
- /* win32 cosmetic lines are endpoint-exclusive, so use CapNotLast */
- gc.base.capStyle = CapNotLast;
- gc.base.joinStyle = JoinMiter;
- gc.base.ops = &ops;
-
- dashed = 0;
- if (stroke->attr.flags & SPICE_LINE_FLAGS_STYLED) {
- SPICE_FIXED28_4 *style = stroke->attr.style;
- int nseg;
-
- dashed = 1;
-
- nseg = stroke->attr.style_nseg;
-
- /* To truly handle back_mode we should use LineDoubleDash here
- and treat !foreground as back_rop using the same brush.
- However, using the same brush for that seems wrong.
- The old cairo backend was stroking the non-dashed line with
- rop_mode before enabling dashes for the foreground which is
- not right either. The gl an gdi backend don't use back_mode
- at all */
- gc.base.lineStyle = LineOnOffDash;
- gc.base.dash = (unsigned char *)spice_malloc(nseg);
- gc.base.numInDashList = nseg;
-
- if (stroke->attr.flags & SPICE_LINE_FLAGS_START_WITH_GAP) {
- gc.base.dash[stroke->attr.style_nseg - 1] = fix_to_int(style[0]);
- for (i = 0; i < (unsigned int)(stroke->attr.style_nseg - 1); i++) {
- gc.base.dash[i] = fix_to_int(style[i+1]);
- }
- gc.base.dashOffset = gc.base.dash[0];
- } else {
- for (i = 0; i < stroke->attr.style_nseg; i++) {
- gc.base.dash[i] = fix_to_int(style[i]);
- }
- }
- }
-
- switch (stroke->brush.type) {
- case SPICE_BRUSH_TYPE_NONE:
- gc.solid = TRUE;
- gc.color = 0;
- break;
- case SPICE_BRUSH_TYPE_SOLID:
- gc.solid = TRUE;
- gc.color = stroke->brush.u.color;
- break;
- case SPICE_BRUSH_TYPE_PATTERN:
- gc.solid = FALSE;
- surface_canvas = canvas_get_surface(canvas,
- stroke->brush.u.pattern.pat);
- if (surface_canvas) {
- gc.use_surface_canvas = TRUE;
- gc.surface_canvas = surface_canvas;
- } else {
- gc.use_surface_canvas = FALSE;
- gc.tile = canvas_get_image(canvas,
- stroke->brush.u.pattern.pat,
- FALSE);
- }
- gc.tile_offset_x = stroke->brush.u.pattern.pos.x;
- gc.tile_offset_y = stroke->brush.u.pattern.pos.y;
- break;
- default:
- CANVAS_ERROR("invalid brush type");
- }
-
- stroke_lines_init(&lines);
-
- for (i = 0; i < stroke->path->num_segments; i++) {
- SpicePathSeg *seg = stroke->path->segments[i];
- SpicePointFix* point, *end_point;
-
- point = seg->points;
- end_point = point + seg->count;
-
- if (seg->flags & SPICE_PATH_BEGIN) {
- stroke_lines_draw(&lines, (lineGC *)&gc, dashed);
- stroke_lines_append_fix(&lines, point);
- point++;
- }
-
- if (seg->flags & SPICE_PATH_BEZIER) {
- ASSERT((point - end_point) % 3 == 0);
- for (; point + 2 < end_point; point += 3) {
- stroke_lines_append_bezier(&lines,
- &point[0],
- &point[1],
- &point[2]);
- }
- } else
- {
- for (; point < end_point; point++) {
- stroke_lines_append_fix(&lines, point);
- }
- }
- if (seg->flags & SPICE_PATH_END) {
- if (seg->flags & SPICE_PATH_CLOSE) {
- stroke_lines_append(&lines,
- lines.points[0].x, lines.points[0].y);
- }
- stroke_lines_draw(&lines, (lineGC *)&gc, dashed);
- }
- }
-
- stroke_lines_draw(&lines, (lineGC *)&gc, dashed);
-
- free(gc.base.dash);
- stroke_lines_free(&lines);
-
- if (!gc.solid && gc.tile && !surface_canvas) {
- pixman_image_unref(gc.tile);
- }
-
- pixman_region32_fini(&gc.dest_region);
-}
-
-
-//need surfaces handling here !!!
-static void canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox,
- SpiceClip *clip, SpiceRop3 *rop3)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- SpiceCanvas *surface_canvas;
- pixman_region32_t dest_region;
- pixman_image_t *d;
- pixman_image_t *s;
- SpicePoint src_pos;
- int width;
- int heigth;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
- canvas_mask_pixman(canvas, &dest_region, &rop3->mask,
- bbox->left, bbox->top);
-
- width = bbox->right - bbox->left;
- heigth = bbox->bottom - bbox->top;
-
- d = canvas_get_image_from_self(spice_canvas, bbox->left, bbox->top, width, heigth);
- surface_canvas = canvas_get_surface(canvas, rop3->src_bitmap);
- if (surface_canvas) {
- s = surface_canvas->ops->get_image(surface_canvas);
- } else {
- s = canvas_get_image(canvas, rop3->src_bitmap, FALSE);
- }
-
- if (!rect_is_same_size(bbox, &rop3->src_area)) {
- pixman_image_t *scaled_s = canvas_scale_surface(s, &rop3->src_area, width, heigth,
- rop3->scale_mode);
- pixman_image_unref(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 (pixman_image_get_width(s) - src_pos.x < width ||
- pixman_image_get_height(s) - src_pos.y < heigth) {
- CANVAS_ERROR("bad src bitmap size");
- }
- if (rop3->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
- SpiceCanvas *_surface_canvas;
- pixman_image_t *p;
-
- _surface_canvas = canvas_get_surface(canvas, rop3->brush.u.pattern.pat);
- if (_surface_canvas) {
- p = _surface_canvas->ops->get_image(_surface_canvas);
- } else {
- p = canvas_get_image(canvas, rop3->brush.u.pattern.pat, FALSE);
- }
- SpicePoint pat_pos;
-
- pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % pixman_image_get_width(p);
- pat_pos.y = (bbox->top - rop3->brush.u.pattern.pos.y) % pixman_image_get_height(p);
- do_rop3_with_pattern(rop3->rop3, d, s, &src_pos, p, &pat_pos);
- pixman_image_unref(p);
- } else {
- do_rop3_with_color(rop3->rop3, d, s, &src_pos, rop3->brush.u.color);
- }
- pixman_image_unref(s);
-
- spice_canvas->ops->blit_image(spice_canvas, &dest_region, d,
- bbox->left,
- bbox->top);
-
- pixman_image_unref(d);
-
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_copy_bits(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_t dest_region;
- int dx, dy;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(canvas, &dest_region, clip);
-
- dx = bbox->left - src_pos->x;
- dy = bbox->top - src_pos->y;
-
- if (dx != 0 || dy != 0) {
- pixman_region32_t src_region;
-
- /* Clip so we don't read outside canvas */
- pixman_region32_init_rect(&src_region,
- dx, dy,
- canvas->width,
- canvas->height);
- pixman_region32_intersect(&dest_region, &dest_region, &src_region);
- pixman_region32_fini(&src_region);
-
- spice_canvas->ops->copy_region(spice_canvas, &dest_region, dx, dy);
- }
-
- pixman_region32_fini(&dest_region);
-}
-
-
-
-static void canvas_base_group_start(SpiceCanvas *spice_canvas, QRegion *region)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_fini(&canvas->canvas_region);
-
- /* Make sure we always clip to canvas size */
- pixman_region32_init_rect(&canvas->canvas_region,
- 0, 0,
- canvas->width,
- canvas->height);
-
- pixman_region32_intersect(&canvas->canvas_region, &canvas->canvas_region, region);
-}
-
-static void canvas_base_group_end(SpiceCanvas *spice_canvas)
-{
- CanvasBase *canvas = (CanvasBase *)spice_canvas;
- pixman_region32_fini(&canvas->canvas_region);
- pixman_region32_init_rect(&canvas->canvas_region,
- 0, 0,
- canvas->width,
- canvas->height);
-}
-
-
-static void unimplemented_op(SpiceCanvas *canvas)
-{
- PANIC("unimplemented canvas operation");
-}
-
-inline static void canvas_base_init_ops(SpiceCanvasOps *ops)
-{
- void **ops_cast;
- unsigned i;
-
- ops_cast = (void **)ops;
- for (i = 0; i < sizeof(SpiceCanvasOps) / sizeof(void *); i++) {
- ops_cast[i] = (void *) unimplemented_op;
- }
-
- ops->draw_fill = canvas_draw_fill;
- ops->draw_copy = canvas_draw_copy;
- ops->draw_opaque = canvas_draw_opaque;
- ops->copy_bits = canvas_copy_bits;
- ops->draw_blend = canvas_draw_blend;
- ops->draw_blackness = canvas_draw_blackness;
- ops->draw_whiteness = canvas_draw_whiteness;
- ops->draw_invers = canvas_draw_invers;
- ops->draw_transparent = canvas_draw_transparent;
- ops->draw_alpha_blend = canvas_draw_alpha_blend;
- ops->draw_stroke = canvas_draw_stroke;
- ops->draw_rop3 = canvas_draw_rop3;
- ops->group_start = canvas_base_group_start;
- ops->group_end = canvas_base_group_end;
-}
-
-static int canvas_base_init(CanvasBase *canvas, SpiceCanvasOps *ops,
- int width, int height, uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- )
-{
- canvas->parent.ops = ops;
- 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;
- if (!(canvas->quic_data.quic = quic_create(&canvas->quic_data.usr))) {
- return 0;
- }
-
- 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;
- }
-
- canvas->surfaces = surfaces;
- canvas->glz_data.decoder = glz_decoder;
- canvas->jpeg = jpeg_decoder;
- canvas->zlib = zlib_decoder;
-
- canvas->format = format;
-
- /* TODO: This is all wrong now */
- if (SPICE_SURFACE_FMT_DEPTH(format) == 16) {
- canvas->color_shift = 5;
- canvas->color_mask = 0x1f;
- } else {
- canvas->color_shift = 8;
- canvas->color_mask = 0xff;
- }
-
- canvas->width = width;
- canvas->height = height;
- pixman_region32_init_rect(&canvas->canvas_region,
- 0, 0,
- canvas->width,
- canvas->height);
-
-#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
- canvas->bits_cache = bits_cache;
-#endif
-#ifdef SW_CANVAS_CACHE
- canvas->palette_cache = palette_cache;
-#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;
-}
diff --git a/common/canvas_base.h b/common/canvas_base.h
deleted file mode 100644
index 861171e..0000000
--- a/common/canvas_base.h
+++ /dev/null
@@ -1,327 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_CANVAS_BASE
-#define _H_CANVAS_BASE
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This header shouldn't be included directly"
-#endif
-
-#include "pixman_utils.h"
-#include "lz.h"
-#include "region.h"
-#include "draw.h"
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void (*spice_destroy_fn_t)(void *data);
-
-typedef struct _SpiceImageCache SpiceImageCache;
-typedef struct _SpiceImageSurfaces SpiceImageSurfaces;
-typedef struct _SpicePaletteCache SpicePaletteCache;
-typedef struct _SpiceGlzDecoder SpiceGlzDecoder;
-typedef struct _SpiceJpegDecoder SpiceJpegDecoder;
-typedef struct _SpiceZlibDecoder SpiceZlibDecoder;
-typedef struct _SpiceCanvas SpiceCanvas;
-
-typedef struct {
- void (*put)(SpiceImageCache *cache,
- uint64_t id,
- pixman_image_t *surface);
- pixman_image_t *(*get)(SpiceImageCache *cache,
- uint64_t id);
-#ifdef SW_CANVAS_CACHE
- void (*put_lossy)(SpiceImageCache *cache,
- uint64_t id,
- pixman_image_t *surface);
- void (*replace_lossy)(SpiceImageCache *cache,
- uint64_t id,
- pixman_image_t *surface);
- pixman_image_t *(*get_lossless)(SpiceImageCache *cache,
- uint64_t id);
-#endif
-} SpiceImageCacheOps;
-
-struct _SpiceImageCache {
- SpiceImageCacheOps *ops;
-};
-
-typedef struct {
- SpiceCanvas *(*get)(SpiceImageSurfaces *surfaces,
- uint32_t surface_id);
-} SpiceImageSurfacesOps;
-
-struct _SpiceImageSurfaces {
- SpiceImageSurfacesOps *ops;
-};
-
-typedef struct {
- void (*put)(SpicePaletteCache *cache,
- SpicePalette *palette);
- SpicePalette *(*get)(SpicePaletteCache *cache,
- uint64_t id);
- void (*release)(SpicePaletteCache *cache,
- SpicePalette *palette);
-} SpicePaletteCacheOps;
-
-struct _SpicePaletteCache {
- SpicePaletteCacheOps *ops;
-};
-
-typedef struct {
- void (*decode)(SpiceGlzDecoder *decoder,
- uint8_t *data,
- SpicePalette *plt,
- void *usr_data);
-} SpiceGlzDecoderOps;
-
-struct _SpiceGlzDecoder {
- SpiceGlzDecoderOps *ops;
-};
-
-
-typedef struct SpiceJpegDecoderOps {
- void (*begin_decode)(SpiceJpegDecoder *decoder,
- uint8_t* data,
- int data_size,
- int* out_width,
- int* out_height);
- void (*decode)(SpiceJpegDecoder *decoder,
- uint8_t* dest,
- int stride,
- int format);
-} SpiceJpegDecoderOps;
-
-struct _SpiceJpegDecoder {
- SpiceJpegDecoderOps *ops;
-};
-
-typedef struct {
- void (*decode)(SpiceZlibDecoder *decoder,
- uint8_t *data,
- int data_size,
- uint8_t *dest,
- int dest_size);
-} SpiceZlibDecoderOps;
-
-struct _SpiceZlibDecoder {
- SpiceZlibDecoderOps *ops;
-};
-
-typedef struct {
- void (*draw_fill)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
- void (*draw_copy)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
- void (*draw_opaque)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
- void (*copy_bits)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
- void (*draw_text)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
- void (*draw_stroke)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
- void (*draw_rop3)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
- void (*draw_blend)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
- void (*draw_blackness)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
- void (*draw_whiteness)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
- void (*draw_invers)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
- void (*draw_transparent)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
- void (*draw_alpha_blend)(SpiceCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlend* alpha_blend);
- void (*put_image)(SpiceCanvas *canvas,
-#ifdef WIN32
- HDC dc,
-#endif
- const SpiceRect *dest, const uint8_t *src_data,
- uint32_t src_width, uint32_t src_height, int src_stride,
- const QRegion *clip);
- void (*clear)(SpiceCanvas *canvas);
- void (*read_bits)(SpiceCanvas *canvas, uint8_t *dest, int dest_stride, const SpiceRect *area);
- void (*group_start)(SpiceCanvas *canvas, QRegion *region);
- void (*group_end)(SpiceCanvas *canvas);
- void (*destroy)(SpiceCanvas *canvas);
-
- /* Implementation vfuncs */
- void (*fill_solid_spans)(SpiceCanvas *canvas,
- SpicePoint *points,
- int *widths,
- int n_spans,
- uint32_t color);
- void (*fill_solid_rects)(SpiceCanvas *canvas,
- pixman_box32_t *rects,
- int n_rects,
- uint32_t color);
- void (*fill_solid_rects_rop)(SpiceCanvas *canvas,
- pixman_box32_t *rects,
- int n_rects,
- uint32_t color,
- SpiceROP rop);
- void (*fill_tiled_rects)(SpiceCanvas *canvas,
- pixman_box32_t *rects,
- int n_rects,
- pixman_image_t *tile,
- int offset_x, int offset_y);
- void (*fill_tiled_rects_from_surface)(SpiceCanvas *canvas,
- pixman_box32_t *rects,
- int n_rects,
- SpiceCanvas *tile,
- int offset_x, int offset_y);
- void (*fill_tiled_rects_rop)(SpiceCanvas *canvas,
- pixman_box32_t *rects,
- int n_rects,
- pixman_image_t *tile,
- int offset_x, int offset_y,
- SpiceROP rop);
- void (*fill_tiled_rects_rop_from_surface)(SpiceCanvas *canvas,
- pixman_box32_t *rects,
- int n_rects,
- SpiceCanvas *tile,
- int offset_x, int offset_y,
- SpiceROP rop);
- void (*blit_image)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y);
- void (*blit_image_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceCanvas *src_image,
- int offset_x, int offset_y);
- void (*blit_image_rop)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y,
- SpiceROP rop);
- void (*blit_image_rop_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceCanvas *src_image,
- int offset_x, int offset_y,
- SpiceROP rop);
- void (*scale_image)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode);
- void (*scale_image_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceCanvas *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode);
- void (*scale_image_rop)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode, SpiceROP rop);
- void (*scale_image_rop_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceCanvas *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode, SpiceROP rop);
- void (*blend_image)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- pixman_image_t *src_image,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- int overall_alpha);
- void (*blend_image_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- SpiceCanvas *src_image,
- int src_has_alpha,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- int overall_alpha);
- void (*blend_scale_image)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- pixman_image_t *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode,
- int overall_alpha);
- void (*blend_scale_image_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- SpiceCanvas *src_image,
- int src_has_alpha,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode,
- int overall_alpha);
- void (*colorkey_image)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y,
- uint32_t transparent_color);
- void (*colorkey_image_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceCanvas *src_image,
- int offset_x, int offset_y,
- uint32_t transparent_color);
- void (*colorkey_scale_image)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- uint32_t transparent_color);
- void (*colorkey_scale_image_from_surface)(SpiceCanvas *canvas,
- pixman_region32_t *region,
- SpiceCanvas *src_image,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- uint32_t transparent_color);
- void (*copy_region)(SpiceCanvas *canvas,
- pixman_region32_t *dest_region,
- int dx, int dy);
- pixman_image_t *(*get_image)(SpiceCanvas *canvas);
-} SpiceCanvasOps;
-
-void spice_canvas_set_usr_data(SpiceCanvas *canvas, void *data, spice_destroy_fn_t destroy_fn);
-void *spice_canvas_get_usr_data(SpiceCanvas *canvas);
-
-struct _SpiceCanvas {
- SpiceCanvasOps *ops;
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/canvas_utils.c b/common/canvas_utils.c
deleted file mode 100644
index 6632942..0000000
--- a/common/canvas_utils.c
+++ /dev/null
@@ -1,299 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "canvas_utils.h"
-
-#include <spice/macros.h>
-
-#ifdef __GNUC__
-#include <stdlib.h>
-#include <stdio.h>
-#endif
-#include "mem.h"
-
-#ifdef WIN32
-static int gdi_handlers = 0;
-#endif
-
-#ifndef CANVAS_ERROR
-#define CANVAS_ERROR(format, ...) { \
- printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__); \
- abort(); \
-}
-#endif
-
-static void release_data(pixman_image_t *image, void *release_data)
-{
- PixmanData *data = (PixmanData *)release_data;
-
-#ifdef WIN32
- if (data->bitmap) {
- DeleteObject((HBITMAP)data->bitmap);
- CloseHandle(data->mutex);
- gdi_handlers--;
- }
-#endif
- free(data->data);
-
- free(data);
-}
-
-static PixmanData *
-pixman_image_add_data(pixman_image_t *image)
-{
- PixmanData *data;
-
- data = (PixmanData *)pixman_image_get_destroy_data(image);
- if (data == NULL) {
- data = (PixmanData *)calloc(1, sizeof(PixmanData));
- if (data == NULL) {
- CANVAS_ERROR("out of memory");
- }
- pixman_image_set_destroy_function(image,
- release_data,
- data);
- }
-
- return data;
-}
-
-void
-spice_pixman_image_set_format(pixman_image_t *image,
- pixman_format_code_t format)
-{
- PixmanData *data;
-
- data = pixman_image_add_data(image);
- data->format = format;
-}
-
-pixman_format_code_t
-spice_pixman_image_get_format(pixman_image_t *image)
-{
- PixmanData *data;
-
- data = (PixmanData *)pixman_image_get_destroy_data(image);
- if (data != NULL &&
- data->format != 0)
- return data->format;
-
- CANVAS_ERROR("Unknown pixman image type");
-}
-
-static INLINE pixman_image_t *__surface_create_stride(pixman_format_code_t format, int width, int height,
- int stride)
-{
- uint8_t *data;
- uint8_t *stride_data;
- pixman_image_t *surface;
- PixmanData *pixman_data;
-
- data = (uint8_t *)spice_malloc_n(abs(stride), height);
- if (stride < 0) {
- stride_data = data + (-stride) * (height - 1);
- } else {
- stride_data = data;
- }
-
- surface = pixman_image_create_bits(format, width, height, (uint32_t *)stride_data, stride);
-
- if (surface == NULL) {
- free(data);
- CANVAS_ERROR("create surface failed, out of memory");
- }
-
- pixman_data = pixman_image_add_data(surface);
- pixman_data->data = data;
- pixman_data->format = format;
-
- return surface;
-}
-
-#ifdef WIN32
-pixman_image_t *surface_create(HDC dc, pixman_format_code_t format,
- int width, int height, int top_down)
-#else
-pixman_image_t * surface_create(pixman_format_code_t format, int width, int height, int top_down)
-#endif
-{
-#ifdef WIN32
- /*
- * Windows xp allow only 10,000 of gdi handlers, considering the fact that
- * we limit here the number to 5000, we dont use atomic operations to sync
- * this calculation against the other canvases (in case of multiple
- * monitors), in worst case there will be little more than 5000 gdi
- * handlers.
- */
- if (dc && gdi_handlers < 5000) {
- uint8_t *data;
- uint8_t *src;
- struct {
- BITMAPINFO inf;
- RGBQUAD palette[255];
- } bitmap_info;
- int nstride;
- pixman_image_t *surface;
- PixmanData *pixman_data;
- HBITMAP bitmap;
- HANDLE mutex;
-
- memset(&bitmap_info, 0, sizeof(bitmap_info));
- bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
- bitmap_info.inf.bmiHeader.biWidth = width;
-
- bitmap_info.inf.bmiHeader.biHeight = (!top_down) ? height : -height;
-
- bitmap_info.inf.bmiHeader.biPlanes = 1;
- switch (format) {
- case PIXMAN_a8r8g8b8:
- case PIXMAN_x8r8g8b8:
- bitmap_info.inf.bmiHeader.biBitCount = 32;
- nstride = width * 4;
- break;
- case PIXMAN_x1r5g5b5:
- case PIXMAN_r5g6b5:
- bitmap_info.inf.bmiHeader.biBitCount = 16;
- nstride = SPICE_ALIGN(width * 2, 4);
- break;
- case PIXMAN_a8:
- bitmap_info.inf.bmiHeader.biBitCount = 8;
- nstride = SPICE_ALIGN(width, 4);
- break;
- case PIXMAN_a1:
- bitmap_info.inf.bmiHeader.biBitCount = 1;
- nstride = SPICE_ALIGN(width, 32) / 8;
- break;
- default:
- CANVAS_ERROR("invalid format");
- }
-
- bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
-
- mutex = CreateMutex(NULL, 0, NULL);
- if (!mutex) {
- CANVAS_ERROR("Unable to CreateMutex");
- }
-
- bitmap = CreateDIBSection(dc, &bitmap_info.inf, 0, (VOID **)&data, NULL, 0);
- if (!bitmap) {
- CloseHandle(mutex);
- CANVAS_ERROR("Unable to CreateDIBSection");
- }
-
- if (top_down) {
- src = data;
- } else {
- src = data + nstride * (height - 1);
- nstride = -nstride;
- }
-
- surface = pixman_image_create_bits(format, width, height, (uint32_t *)src, nstride);
- if (surface == NULL) {
- CloseHandle(mutex);
- DeleteObject(bitmap);
- CANVAS_ERROR("create surface failed, out of memory");
- }
- pixman_data = pixman_image_add_data(surface);
- pixman_data->format = format;
- pixman_data->bitmap = bitmap;
- pixman_data->mutex = mutex;
- gdi_handlers++;
- return surface;
- } else {
-#endif
- if (top_down) {
- pixman_image_t *surface;
- PixmanData *data;
-
- surface = pixman_image_create_bits(format, width, height, NULL, 0);
- data = pixman_image_add_data(surface);
- data->format = format;
- return surface;
- } else {
- // NOTE: we assume here that the lz decoders always decode to RGB32.
- int stride = 0;
- switch (format) {
- case PIXMAN_a8r8g8b8:
- case PIXMAN_x8r8g8b8:
- stride = width * 4;
- break;
- case PIXMAN_x1r5g5b5:
- case PIXMAN_r5g6b5:
- stride = SPICE_ALIGN(width * 2, 4);
- break;
- case PIXMAN_a8:
- stride = SPICE_ALIGN(width, 4);
- break;
- case PIXMAN_a1:
- stride = SPICE_ALIGN(width, 32) / 8;
- break;
- default:
- CANVAS_ERROR("invalid format");
- }
- stride = -stride;
- return __surface_create_stride(format, width, height, stride);
- }
-#ifdef WIN32
-}
-
-#endif
-}
-
-#ifdef WIN32
-pixman_image_t *surface_create_stride(HDC dc, pixman_format_code_t format, int width, int height,
- int stride)
-#else
-pixman_image_t *surface_create_stride(pixman_format_code_t format, int width, int height,
- int stride)
-#endif
-{
-#ifdef WIN32
- if (dc) {
- if (abs(stride) == (width * 4)) {
- return surface_create(dc, format, width, height, (stride > 0));
- }
- }
-#endif
-
- return __surface_create_stride(format, width, height, stride);
-}
-
-pixman_image_t *alloc_lz_image_surface(LzDecodeUsrData *canvas_data,
- pixman_format_code_t pixman_format, int width,
- int height, int gross_pixels, int top_down)
-{
- int stride;
- pixman_image_t *surface = NULL;
-
- stride = (gross_pixels / height) * (PIXMAN_FORMAT_BPP (pixman_format) / 8);
-
- if (!top_down) {
- stride = -stride;
- }
-
- surface = surface_create_stride(
-#ifdef WIN32
- canvas_data->dc,
-#endif
- pixman_format, width, height, stride);
- canvas_data->out_surface = surface;
- return surface;
-}
diff --git a/common/canvas_utils.h b/common/canvas_utils.h
deleted file mode 100644
index 16ada45..0000000
--- a/common/canvas_utils.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_CANVAS_UTILS
-#define _H_CANVAS_UTILS
-
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-#include <spice/types.h>
-
-#include "pixman_utils.h"
-#include "lz.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct PixmanData {
-#ifdef WIN32
- HBITMAP bitmap;
- HANDLE mutex;
-#endif
- uint8_t *data;
- pixman_format_code_t format;
-} PixmanData;
-
-void spice_pixman_image_set_format(pixman_image_t *image,
- pixman_format_code_t format);
-pixman_format_code_t spice_pixman_image_get_format(pixman_image_t *image);
-
-
-#ifdef WIN32
-pixman_image_t *surface_create(HDC dc, pixman_format_code_t format,
- int width, int height, int top_down);
-#else
-pixman_image_t *surface_create(pixman_format_code_t format, int width, int height, int top_down);
-#endif
-
-#ifdef WIN32
-pixman_image_t *surface_create_stride(HDC dc, pixman_format_code_t format, int width, int height,
- int stride);
-#else
-pixman_image_t *surface_create_stride(pixman_format_code_t format, int width, int height,
- int stride);
-#endif
-
-
-typedef struct LzDecodeUsrData {
-#ifdef WIN32
- HDC dc;
-#endif
- pixman_image_t *out_surface;
-} LzDecodeUsrData;
-
-
-pixman_image_t *alloc_lz_image_surface(LzDecodeUsrData *canvas_data,
- pixman_format_code_t pixman_format, int width,
- int height, int gross_pixels, int top_down);
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/draw.h b/common/draw.h
deleted file mode 100644
index 8b1206d..0000000
--- a/common/draw.h
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in
- the documentation and/or other materials provided with the
- distribution.
- * Neither the name of the copyright holder nor the names of its
- contributors may be used to endorse or promote products derived
- from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
- IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef _H_SPICE_DRAW
-#define _H_SPICE_DRAW
-
-#include <spice/types.h>
-#include <spice/enums.h>
-#include "mem.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SPICE_GET_ADDRESS(addr) ((void *)(uintptr_t)(addr))
-#define SPICE_SET_ADDRESS(addr, val) ((addr) = (uintptr_t)(val))
-
-typedef int32_t SPICE_FIXED28_4;
-
-typedef struct SpicePointFix {
- SPICE_FIXED28_4 x;
- SPICE_FIXED28_4 y;
-} SpicePointFix;
-
-typedef struct SpicePoint {
- int32_t x;
- int32_t y;
-} SpicePoint;
-
-typedef struct SpicePoint16 {
- int16_t x;
- int16_t y;
-} SpicePoint16;
-
-typedef struct SpiceRect {
- int32_t left;
- int32_t top;
- int32_t right;
- int32_t bottom;
-} SpiceRect;
-
-typedef struct SpicePathSeg {
- uint32_t flags;
- uint32_t count;
- SpicePointFix points[0];
-} SpicePathSeg;
-
-typedef struct SpicePath {
- uint32_t num_segments;
- SpicePathSeg *segments[0];
-} SpicePath;
-
-typedef struct SpiceClipRects {
- uint32_t num_rects;
- SpiceRect rects[0];
-} SpiceClipRects;
-
-typedef struct SpiceClip {
- uint32_t type;
- SpiceClipRects *rects;
-} SpiceClip;
-
-typedef struct SpicePalette {
- uint64_t unique;
- uint16_t num_ents;
- uint32_t ents[0];
-} SpicePalette;
-
-#define SPICE_SURFACE_FMT_DEPTH(_d) ((_d) & 0x3f)
-
-typedef struct SpiceImageDescriptor {
- uint64_t id;
- uint8_t type;
- uint8_t flags;
- uint32_t width;
- uint32_t height;
-} SpiceImageDescriptor;
-
-typedef struct SpiceBitmap {
- uint8_t format;
- uint8_t flags;
- uint32_t x;
- uint32_t y;
- uint32_t stride;
- SpicePalette *palette;
- uint64_t palette_id;
- SpiceChunks *data;
-} SpiceBitmap;
-
-typedef struct SpiceSurface {
- uint32_t surface_id;
-} SpiceSurface;
-
-typedef struct SpiceQUICData {
- uint32_t data_size;
- SpiceChunks *data;
-} SpiceQUICData, SpiceLZRGBData, SpiceJPEGData;
-
-typedef struct SpiceLZPLTData {
- uint8_t flags;
- uint32_t data_size;
- SpicePalette *palette;
- uint64_t palette_id;
- SpiceChunks *data;
-} SpiceLZPLTData;
-
-typedef struct SpiceZlibGlzRGBData {
- uint32_t glz_data_size;
- uint32_t data_size;
- SpiceChunks *data;
-} SpiceZlibGlzRGBData;
-
-typedef struct SpiceJPEGAlphaData {
- uint8_t flags;
- uint32_t jpeg_size;
- uint32_t data_size;
- SpiceChunks *data;
-} SpiceJPEGAlphaData;
-
-
-typedef struct SpiceImage {
- SpiceImageDescriptor descriptor;
- union {
- SpiceBitmap bitmap;
- SpiceQUICData quic;
- SpiceSurface surface;
- SpiceLZRGBData lz_rgb;
- SpiceLZPLTData lz_plt;
- SpiceJPEGData jpeg;
- SpiceZlibGlzRGBData zlib_glz;
- SpiceJPEGAlphaData jpeg_alpha;
- } u;
-} SpiceImage;
-
-typedef struct SpicePattern {
- SpiceImage *pat;
- SpicePoint pos;
-} SpicePattern;
-
-typedef struct SpiceBrush {
- uint32_t type;
- union {
- uint32_t color;
- SpicePattern pattern;
- } u;
-} SpiceBrush;
-
-typedef struct SpiceQMask {
- uint8_t flags;
- SpicePoint pos;
- SpiceImage *bitmap;
-} SpiceQMask;
-
-typedef struct SpiceFill {
- SpiceBrush brush;
- uint16_t rop_descriptor;
- SpiceQMask mask;
-} SpiceFill;
-
-typedef struct SpiceOpaque {
- SpiceImage *src_bitmap;
- SpiceRect src_area;
- SpiceBrush brush;
- uint16_t rop_descriptor;
- uint8_t scale_mode;
- SpiceQMask mask;
-} SpiceOpaque;
-
-typedef struct SpiceCopy {
- SpiceImage *src_bitmap;
- SpiceRect src_area;
- uint16_t rop_descriptor;
- uint8_t scale_mode;
- SpiceQMask mask;
-} SpiceCopy, SpiceBlend;
-
-typedef struct SpiceTransparent {
- SpiceImage *src_bitmap;
- SpiceRect src_area;
- uint32_t src_color;
- uint32_t true_color;
-} SpiceTransparent;
-
-typedef struct SpiceAlphaBlend {
- uint16_t alpha_flags;
- uint8_t alpha;
- SpiceImage *src_bitmap;
- SpiceRect src_area;
-} SpiceAlphaBlend;
-
-typedef struct SpiceRop3 {
- SpiceImage *src_bitmap;
- SpiceRect src_area;
- SpiceBrush brush;
- uint8_t rop3;
- uint8_t scale_mode;
- SpiceQMask mask;
-} SpiceRop3;
-
-typedef struct SpiceBlackness {
- SpiceQMask mask;
-} SpiceBlackness, SpiceInvers, SpiceWhiteness;
-
-typedef struct SpiceLineAttr {
- uint8_t flags;
- uint8_t style_nseg;
- SPICE_FIXED28_4 *style;
-} SpiceLineAttr;
-
-typedef struct SpiceStroke {
- SpicePath *path;
- SpiceLineAttr attr;
- SpiceBrush brush;
- uint16_t fore_mode;
- uint16_t back_mode;
-} SpiceStroke;
-
-typedef struct SpiceRasterGlyph {
- SpicePoint render_pos;
- SpicePoint glyph_origin;
- uint16_t width;
- uint16_t height;
- uint8_t data[0];
-} SpiceRasterGlyph;
-
-typedef struct SpiceString {
- uint16_t length;
- uint16_t flags;
- SpiceRasterGlyph *glyphs[0];
-} SpiceString;
-
-typedef struct SpiceText {
- SpiceString *str;
- SpiceRect back_area;
- SpiceBrush fore_brush;
- SpiceBrush back_brush;
- uint16_t fore_mode;
- uint16_t back_mode;
-} SpiceText;
-
-typedef struct SpiceCursorHeader {
- uint64_t unique;
- uint16_t type;
- uint16_t width;
- uint16_t height;
- uint16_t hot_spot_x;
- uint16_t hot_spot_y;
-} SpiceCursorHeader;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _H_SPICE_DRAW */
diff --git a/common/gdi_canvas.c b/common/gdi_canvas.c
deleted file mode 100644
index d3e9c7f..0000000
--- a/common/gdi_canvas.c
+++ /dev/null
@@ -1,1858 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#ifdef __MINGW32__
-#undef HAVE_STDLIB_H
-#endif
-#include <config.h>
-#endif
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This file shouldn't be compiled directly"
-#endif
-
-#include <windows.h>
-#include <wingdi.h>
-#include "gdi_canvas.h"
-#define GDI_CANVAS
-#include "canvas_base.c"
-#include "rop3.h"
-#include "rect.h"
-#include "region.h"
-#include "threads.h"
-
-typedef struct GdiCanvas GdiCanvas;
-
-struct GdiCanvas {
- CanvasBase base;
- HDC dc;
- RecurciveMutex* lock;
-};
-
-
-struct BitmapData {
- HBITMAP hbitmap;
- HBITMAP prev_hbitmap;
- SpicePoint pos;
- uint8_t flags;
- HDC dc;
- int cache;
- int from_surface;
-};
-
-#define _rop3_brush 0xf0
-#define _rop3_src 0xcc
-#define _rop3_dest 0xaa
-
-uint32_t raster_ops[] = {
- 0x00000042,
- 0x00010289,
- 0x00020C89,
- 0x000300AA,
- 0x00040C88,
- 0x000500A9,
- 0x00060865,
- 0x000702C5,
- 0x00080F08,
- 0x00090245,
- 0x000A0329,
- 0x000B0B2A,
- 0x000C0324,
- 0x000D0B25,
- 0x000E08A5,
- 0x000F0001,
- 0x00100C85,
- 0x001100A6,
- 0x00120868,
- 0x001302C8,
- 0x00140869,
- 0x001502C9,
- 0x00165CCA,
- 0x00171D54,
- 0x00180D59,
- 0x00191CC8,
- 0x001A06C5,
- 0x001B0768,
- 0x001C06CA,
- 0x001D0766,
- 0x001E01A5,
- 0x001F0385,
- 0x00200F09,
- 0x00210248,
- 0x00220326,
- 0x00230B24,
- 0x00240D55,
- 0x00251CC5,
- 0x002606C8,
- 0x00271868,
- 0x00280369,
- 0x002916CA,
- 0x002A0CC9,
- 0x002B1D58,
- 0x002C0784,
- 0x002D060A,
- 0x002E064A,
- 0x002F0E2A,
- 0x0030032A,
- 0x00310B28,
- 0x00320688,
- 0x00330008,
- 0x003406C4,
- 0x00351864,
- 0x003601A8,
- 0x00370388,
- 0x0038078A, // PSDPoax
- 0x00390604, // SPDnox
- 0x003A0644, // SPDSxox
- 0x003B0E24, // SPDnoan
- 0x003C004A, // PSx
- 0x003D18A4, // SPDSonox
- 0x003E1B24, // SPDSnaox
- 0x003F00EA, // PSan
- 0x00400F0A, // PSDnaa
- 0x00410249, // DPSxon
- 0x00420D5D, // SDxPDxa
- 0x00431CC4, // SPDSanaxn
- 0x00440328, // SDna SRCERASE
- 0x00450B29, // DPSnaon
- 0x004606C6, // DSPDaox
- 0x0047076A, // PSDPxaxn
- 0x00480368, // SDPxa
- 0x004916C5, // PDSPDaoxxn
- 0x004A0789, // DPSDoax
- 0x004B0605, // PDSnox
- 0x004C0CC8, // SDPana
- 0x004D1954, // SSPxDSxoxn
- 0x004E0645, // PDSPxox
- 0x004F0E25, // PDSnoan
- 0x00500325, // PDna
- 0x00510B26, // DSPnaon
- 0x005206C9, // DPSDaox
- 0x00530764, // SPDSxaxn
- 0x005408A9, // DPSonon
- 0x00550009, // Dn DSTINVERT
- 0x005601A9, // DPSox
- 0x00570389, // DPSoan
- 0x00580785, // PDSPoax
- 0x00590609, // DPSnox
- 0x005A0049, // DPx PATINVERT
- 0x005B18A9, // DPSDonox
- 0x005C0649, // DPSDxox
- 0x005D0E29, // DPSnoan
- 0x005E1B29, // DPSDnaox
- 0x005F00E9, // DPan
- 0x00600365, // PDSxa
- 0x006116C6, // DSPDSaoxxn
- 0x00620786, // DSPDoax
- 0x00630608, // SDPnox
- 0x00640788, // SDPSoax
- 0x00650606, // DSPnox
- 0x00660046, // DSx SRCINVERT
- 0x006718A8, // SDPSonox
- 0x006858A6, // DSPDSonoxxn
- 0x00690145, // PDSxxn
- 0x006A01E9, // DPSax
- 0x006B178A, // PSDPSoaxxn
- 0x006C01E8, // SDPax
- 0x006D1785, // PDSPDoaxxn
- 0x006E1E28, // SDPSnoax
- 0x006F0C65, // PDSxnan
- 0x00700CC5, // PDSana
- 0x00711D5C, // SSDxPDxaxn
- 0x00720648, // SDPSxox
- 0x00730E28, // SDPnoan
- 0x00740646, // DSPDxox
- 0x00750E26, // DSPnoan
- 0x00761B28, // SDPSnaox
- 0x007700E6, // DSan
- 0x007801E5, // PDSax
- 0x00791786, // DSPDSoaxxn
- 0x007A1E29, // DPSDnoax
- 0x007B0C68, // SDPxnan
- 0x007C1E24, // SPDSnoax
- 0x007D0C69, // DPSxnan
- 0x007E0955, // SPxDSxo
- 0x007F03C9, // DPSaan
- 0x008003E9, // DPSaa
- 0x00810975, // SPxDSxon
- 0x00820C49, // DPSxna
- 0x00831E04, // SPDSnoaxn
- 0x00840C48, // SDPxna
- 0x00851E05, // PDSPnoaxn
- 0x008617A6, // DSPDSoaxx
- 0x008701C5, // PDSaxn
- 0x008800C6, // DSa SRCAND
- 0x00891B08, // SDPSnaoxn
- 0x008A0E06, // DSPnoa
- 0x008B0666, // DSPDxoxn
- 0x008C0E08, // SDPnoa
- 0x008D0668, // SDPSxoxn
- 0x008E1D7C, // SSDxPDxax
- 0x008F0CE5, // PDSanan
- 0x00900C45, // PDSxna
- 0x00911E08, // SDPSnoaxn
- 0x009217A9, // DPSDPoaxx
- 0x009301C4, // SPDaxn
- 0x009417AA, // PSDPSoaxx
- 0x009501C9, // DPSaxn
- 0x00960169, // DPSxx
- 0x0097588A, // PSDPSonoxx
- 0x00981888, // SDPSonoxn
- 0x00990066, // DSxn
- 0x009A0709, // DPSnax
- 0x009B07A8, // SDPSoaxn
- 0x009C0704, // SPDnax
- 0x009D07A6, // DSPDoaxn
- 0x009E16E6, // DSPDSaoxx
- 0x009F0345, // PDSxan
- 0x00A000C9, // DPa
- 0x00A11B05, // PDSPnaoxn
- 0x00A20E09, // DPSnoa
- 0x00A30669, // DPSDxoxn
- 0x00A41885, // PDSPonoxn
- 0x00A50065, // PDxn
- 0x00A60706, // DSPnax
- 0x00A707A5, // PDSPoaxn
- 0x00A803A9, // DPSoa
- 0x00A90189, // DPSoxn
- 0x00AA0029, // D
- 0x00AB0889, // DPSono
- 0x00AC0744, // SPDSxax
- 0x00AD06E9, // DPSDaoxn
- 0x00AE0B06, // DSPnao
- 0x00AF0229, // DPno
- 0x00B00E05, // PDSnoa
- 0x00B10665, // PDSPxoxn
- 0x00B21974, // SSPxDSxox
- 0x00B30CE8, // SDPanan
- 0x00B4070A, // PSDnax
- 0x00B507A9, // DPSDoaxn
- 0x00B616E9, // DPSDPaoxx
- 0x00B70348, // SDPxan
- 0x00B8074A, // PSDPxax
- 0x00B906E6, // DSPDaoxn
- 0x00BA0B09, // DPSnao
- 0x00BB0226, // DSno MERGEPAINT
- 0x00BC1CE4, // SPDSanax
- 0x00BD0D7D, // SDxPDxan
- 0x00BE0269, // DPSxo
- 0x00BF08C9, // DPSano
- 0x00C000CA, // PSa MERGECOPY
- 0x00C11B04, // SPDSnaoxn
- 0x00C21884, // SPDSonoxn
- 0x00C3006A, // PSxn
- 0x00C40E04, // SPDnoa
- 0x00C50664, // SPDSxoxn
- 0x00C60708, // SDPnax
- 0x00C707AA, // PSDPoaxn
- 0x00C803A8, // SDPoa
- 0x00C90184, // SPDoxn
- 0x00CA0749, // DPSDxax
- 0x00CB06E4, // SPDSaoxn
- 0x00CC0020, // S SRCCOPY
- 0x00CD0888, // SDPono
- 0x00CE0B08, // SDPnao
- 0x00CF0224, // SPno
- 0x00D00E0A, // PSDnoa
- 0x00D1066A, // PSDPxoxn
- 0x00D20705, // PDSnax
- 0x00D307A4, // SPDSoaxn
- 0x00D41D78, // SSPxPDxax
- 0x00D50CE9, // DPSanan
- 0x00D616EA, // PSDPSaoxx
- 0x00D70349, // DPSxan
- 0x00D80745, // PDSPxax
- 0x00D906E8, // SDPSaoxn
- 0x00DA1CE9, // DPSDanax
- 0x00DB0D75, // SPxDSxan
- 0x00DC0B04, // SPDnao
- 0x00DD0228, // SDno
- 0x00DE0268, // SDPxo
- 0x00DF08C8, // SDPano
- 0x00E003A5, // PDSoa
- 0x00E10185, // PDSoxn
- 0x00E20746, // DSPDxax
- 0x00E306EA, // PSDPaoxn
- 0x00E40748, // SDPSxax
- 0x00E506E5, // PDSPaoxn
- 0x00E61CE8, // SDPSanax
- 0x00E70D79, // SPxPDxan
- 0x00E81D74, // SSPxDSxax
- 0x00E95CE6, // DSPDSanaxxn
- 0x00EA02E9, // DPSao
- 0x00EB0849, // DPSxno
- 0x00EC02E8, // SDPao
- 0x00ED0848, // SDPxno
- 0x00EE0086, // DSo SRCPAINT
- 0x00EF0A08, // SDPnoo
- 0x00F00021, // P PATCOPY
- 0x00F10885, // PDSono
- 0x00F20B05, // PDSnao
- 0x00F3022A, // PSno
- 0x00F40B0A, // PSDnao
- 0x00F50225, // PDno
- 0x00F60265, // PDSxo
- 0x00F708C5, // PDSano
- 0x00F802E5, // PDSao
- 0x00F90845, // PDSxno
- 0x00FA0089, // DPo
- 0x00FB0A09, // DPSnoo PATPAINT
- 0x00FC008A, // PSo
- 0x00FD0A0A, // PSDnoo
- 0x00FE02A9, // DPSoo
- 0x00FF0062 // 1 WHITENESS
-};
-
-static void set_path(GdiCanvas *canvas, SpicePath *s)
-{
- unsigned int i;
-
- for (i = 0; i < s->num_segments; i++) {
- SpicePathSeg* seg = s->segments[0];
- SpicePointFix* point = seg->points;
- SpicePointFix* end_point = point + seg->count;
-
- if (seg->flags & SPICE_PATH_BEGIN) {
- BeginPath(canvas->dc);
- if (!MoveToEx(canvas->dc, (int)fix_to_double(point->x), (int)fix_to_double(point->y),
- NULL)) {
- CANVAS_ERROR("MoveToEx failed");
- return;
- }
- point++;
- }
-
- if (seg->flags & SPICE_PATH_BEZIER) {
- ASSERT((point - end_point) % 3 == 0);
- for (; point + 2 < end_point; point += 3) {
- POINT points[3];
-
- points[0].x = (int)fix_to_double(point[0].x);
- points[0].y = (int)fix_to_double(point[0].y);
- points[1].x = (int)fix_to_double(point[1].x);
- points[1].y = (int)fix_to_double(point[1].y);
- points[2].x = (int)fix_to_double(point[2].x);
- points[2].y = (int)fix_to_double(point[2].y);
- if (!PolyBezierTo(canvas->dc, points, 3)) {
- CANVAS_ERROR("PolyBezierTo failed");
- return;
- }
- }
- } else {
- for (; point < end_point; point++) {
- if (!LineTo(canvas->dc, (int)fix_to_double(point->x),
- (int)fix_to_double(point->y))) {
- CANVAS_ERROR("LineTo failed");
- }
- }
- }
-
- if (seg->flags & SPICE_PATH_END) {
-
- if (seg->flags & SPICE_PATH_CLOSE) {
- if (!CloseFigure(canvas->dc)) {
- CANVAS_ERROR("CloseFigure failed");
- }
- }
-
- if (!EndPath(canvas->dc)) {
- CANVAS_ERROR("EndPath failed");
- }
- }
-
- }
-}
-
-static void set_scale_mode(GdiCanvas *canvas, uint8_t scale_mode)
-{
- if (scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE) {
- SetStretchBltMode(canvas->dc, HALFTONE);
- } else if (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) {
- SetStretchBltMode(canvas->dc, COLORONCOLOR);
- } else {
- CANVAS_ERROR("Unknown ScaleMode");
- }
-}
-
-static void set_clip(GdiCanvas *canvas, SpiceClip *clip)
-{
- switch (clip->type) {
- case SPICE_CLIP_TYPE_NONE:
- if (SelectClipRgn(canvas->dc, NULL) == ERROR) {
- CANVAS_ERROR("SelectClipRgn failed");
- }
- break;
- case SPICE_CLIP_TYPE_RECTS: {
- uint32_t n = clip->rects->num_rects;
-
- SpiceRect *now = clip->rects->rects;
- SpiceRect *end = now + n;
-
- if (now < end) {
- HRGN main_hrgn;
-
- main_hrgn = CreateRectRgn(now->left, now->top, now->right, now->bottom);
- if (!main_hrgn) {
- return;
- }
- now++;
- for (; now < end; now++) {
- HRGN combaine_hrgn;
- combaine_hrgn = CreateRectRgn(now->left, now->top, now->right,
- now->bottom);
- if (!combaine_hrgn) {
- CANVAS_ERROR("Unable to CreateRectRgn");
- DeleteObject(main_hrgn);
- return;
- }
- if (CombineRgn(main_hrgn, main_hrgn, combaine_hrgn, RGN_OR) == ERROR) {
- CANVAS_ERROR("Unable to CombineRgn");
- DeleteObject(combaine_hrgn);
- return;
- }
- DeleteObject(combaine_hrgn);
- }
- if (SelectClipRgn(canvas->dc, main_hrgn) == ERROR) {
- CANVAS_ERROR("Unable to SelectClipRgn");
- }
- DeleteObject(main_hrgn);
- }
- break;
- }
- default:
- CANVAS_ERROR("invalid clip type");
- }
-}
-
-static void copy_bitmap(const uint8_t *src_image, int height, int src_stride,
- uint8_t *dest_bitmap, int dest_stride)
-{
- int copy_width = MIN(dest_stride, src_stride);
- int y = 0;
-
- ASSERT(dest_stride >= 0 && src_stride >= 0);
- while (y < height) {
- memcpy(dest_bitmap, src_image, copy_width);
- src_image += src_stride;
- dest_bitmap += dest_stride;
- y++;
- }
-}
-
-static void copy_bitmap_alpha(const uint8_t *src_alpha, int height, int width, int src_stride,
- uint8_t *dest_bitmap, int dest_stride, int alpha_bits_size)
-{
- int y = 0;
- uint8_t i_offset;
- int i_count = 0;
- int i = 0;
-
- if (alpha_bits_size == 1) {
- i_offset = 1;
- } else {
- i_offset = 8;
- }
-
-
- while (y < height) {
- int x;
-
- for (x = 0; x < width; ++x) {
- uint8_t alphaval;
- double alpha;
-
- alphaval = src_alpha[i];
- alphaval = alphaval >> (i_count * i_offset);
- alphaval &= ((uint8_t)0xff >> (8 - i_offset));
- alphaval = ((255 * alphaval) / ((uint8_t)0xff >> (8 - i_offset)));
-
- dest_bitmap[x * 4 + 3] = alphaval;
- alpha = (double)alphaval / 0xff;
- dest_bitmap[x * 4 + 2] = (uint8_t)(alpha * dest_bitmap[x * 4 + 2]);
- dest_bitmap[x * 4 + 1] = (uint8_t)(alpha * dest_bitmap[x * 4 + 1]);
- dest_bitmap[x * 4] = (uint8_t)(alpha * dest_bitmap[x * 4]);
-
- i_count++;
- if (i_count == (8 / i_offset)) {
- i++;
- i_count = 0;
- }
- }
-
- dest_bitmap += width * 4;
- i = 0;
- src_alpha += src_stride;
- i_count = 0;
- y++;
- }
-}
-
-static uint8_t *create_bitmap(HBITMAP *bitmap, HBITMAP *prev_bitmap, HDC *dc,
- const uint8_t *bitmap_data, int width, int height,
- int stride, int bits, int rotate)
-{
- uint8_t *data;
- const uint8_t *src_data;
- uint32_t nstride;
- struct {
- BITMAPINFO inf;
- RGBQUAD palette[255];
- } bitmap_info;
-
- memset(&bitmap_info, 0, sizeof(bitmap_info));
- bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
- bitmap_info.inf.bmiHeader.biWidth = width;
- if (stride < 0) {
- bitmap_info.inf.bmiHeader.biHeight = height;
- } else {
- bitmap_info.inf.bmiHeader.biHeight = -height;
- }
-
- if (rotate) {
- bitmap_info.inf.bmiHeader.biHeight = -bitmap_info.inf.bmiHeader.biHeight;
- }
-
- bitmap_info.inf.bmiHeader.biPlanes = 1;
- bitmap_info.inf.bmiHeader.biBitCount = bits;
- bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
-
- *dc = create_compatible_dc();
- if (!*dc) {
- CANVAS_ERROR("create_compatible_dc() failed");
- return NULL;
- }
-
- *bitmap = CreateDIBSection(*dc, &bitmap_info.inf, 0, (VOID **)&data, NULL, 0);
- if (!*bitmap) {
- CANVAS_ERROR("Unable to CreateDIBSection");
- DeleteDC(*dc);
- return NULL;
- }
- *prev_bitmap = (HBITMAP)SelectObject(*dc, *bitmap);
-
- if (stride < 0) {
- src_data = bitmap_data - (height - 1) * -stride;
- } else {
- src_data = bitmap_data;
- }
-
- switch (bits) {
- case 1:
- nstride = SPICE_ALIGN(width, 32) / 8;
- break;
- case 8:
- nstride = SPICE_ALIGN(width, 4);
- break;
- case 16:
- nstride = SPICE_ALIGN(width * 2, 4);
- break;
- case 32:
- nstride = width * 4;
- break;
- default:
- CANVAS_ERROR("invalid bitmap bits size");
- }
-
- if (bitmap_data) {
- if (stride < 0) {
- copy_bitmap(src_data, height, -stride, data, nstride);
- } else {
- copy_bitmap(src_data, height, stride, data, nstride);
- }
- }
-
- return data;
-}
-
-static uint8_t *create_bitmap_from_pixman(HBITMAP *bitmap, HBITMAP *prev_bitmap, HDC *dc,
- pixman_image_t *surface, int rotate)
-{
- return create_bitmap(bitmap, prev_bitmap, dc,
- (uint8_t*)pixman_image_get_data(surface),
- pixman_image_get_width(surface),
- pixman_image_get_height(surface),
- pixman_image_get_stride(surface),
- spice_pixman_image_get_bpp(surface),
- rotate);
-}
-
-
-static void release_bitmap(HDC dc, HBITMAP bitmap, HBITMAP prev_bitmap, int cache)
-{
- bitmap = (HBITMAP)SelectObject(dc, prev_bitmap);
- if (!cache) {
- DeleteObject(bitmap);
- }
- DeleteDC(dc);
-}
-
-static inline uint8_t get_converted_color(uint8_t color)
-{
- uint8_t msb;
-
- msb = color & 0xE0;
- msb = msb >> 5;
- color |= msb;
- return color;
-}
-
-static inline COLORREF get_color_ref(GdiCanvas *canvas, uint32_t color)
-{
- int shift = canvas->base.color_shift == 8 ? 0 : 3;
- uint8_t r, g, b;
-
- b = (color & canvas->base.color_mask);
- color >>= canvas->base.color_shift;
- g = (color & canvas->base.color_mask);
- color >>= canvas->base.color_shift;
- r = (color & canvas->base.color_mask);
- if (shift) {
- r = get_converted_color(r << shift);
- g = get_converted_color(g << shift);
- b = get_converted_color(b << shift);
- }
- return RGB(r, g, b);
-}
-
-static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush, RecurciveMutex **brush_lock)
-{
- HBRUSH hbrush;
-
- *brush_lock = NULL;
-
- switch (brush->type) {
- case SPICE_BRUSH_TYPE_SOLID:
- if (!(hbrush = CreateSolidBrush(get_color_ref(canvas, brush->u.color)))) {
- CANVAS_ERROR("CreateSolidBrush failed");
- }
- return hbrush;
- case SPICE_BRUSH_TYPE_PATTERN: {
- GdiCanvas *gdi_surface = NULL;
- HBRUSH hbrush;
- pixman_image_t *surface = NULL;
- HDC dc;
- HBITMAP bitmap;
- HBITMAP prev_bitmap;
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, brush->u.pattern.pat);
- if (gdi_surface) {
- bitmap = (HBITMAP)GetCurrentObject(gdi_surface->dc, OBJ_BITMAP);
- if (!bitmap) {
- CANVAS_ERROR("GetCurrentObject failed");
- }
- *brush_lock = gdi_surface->lock;
- } else {
- surface = canvas_get_image(&canvas->base, brush->u.pattern.pat, FALSE);
- if (!create_bitmap_from_pixman(&bitmap, &prev_bitmap, &dc, surface, 0)) {
- CANVAS_ERROR("create_bitmap failed");
- return NULL;
- }
- }
-
- if (!(hbrush = CreatePatternBrush(bitmap))) {
- CANVAS_ERROR("CreatePatternBrush failed");
- }
-
- if (!gdi_surface) {
- release_bitmap(dc, bitmap, prev_bitmap, 0);
- pixman_image_unref(surface);
- }
- return hbrush;
- }
- case SPICE_BRUSH_TYPE_NONE:
- return NULL;
- default:
- CANVAS_ERROR("invalid brush type");
- return NULL;
- }
-}
-
-static HBRUSH set_brush(HDC dc, HBRUSH hbrush, SpiceBrush *brush)
-{
- switch (brush->type) {
- case SPICE_BRUSH_TYPE_SOLID: {
- return (HBRUSH)SelectObject(dc, hbrush);
- }
- case SPICE_BRUSH_TYPE_PATTERN: {
- HBRUSH prev_hbrush;
- prev_hbrush = (HBRUSH)SelectObject(dc, hbrush);
- if (!SetBrushOrgEx(dc, brush->u.pattern.pos.x, brush->u.pattern.pos.y, NULL)) {
- CANVAS_ERROR("SetBrushOrgEx failed");
- }
- return prev_hbrush;
- }
- default:
- CANVAS_ERROR("invalid brush type");
- return NULL;
- }
-}
-
-static void unset_brush(HDC dc, HBRUSH prev_hbrush)
-{
- if (!prev_hbrush) {
- return;
- }
- prev_hbrush = (HBRUSH)SelectObject(dc, prev_hbrush);
- DeleteObject(prev_hbrush);
-}
-
-uint8_t calc_rop3(uint16_t rop3_bits, int brush)
-{
- uint8_t rop3 = 0;
- uint8_t rop3_src = _rop3_src;
- uint8_t rop3_dest = _rop3_dest;
- uint8_t rop3_brush = _rop3_brush;
- uint8_t rop3_src_brush;
-
- if (rop3_bits & SPICE_ROPD_INVERS_SRC) {
- rop3_src = ~rop3_src;
- }
- if (rop3_bits & SPICE_ROPD_INVERS_BRUSH) {
- rop3_brush = ~rop3_brush;
- }
- if (rop3_bits & SPICE_ROPD_INVERS_DEST) {
- rop3_dest = ~rop3_dest;
- }
-
- if (brush) {
- rop3_src_brush = rop3_brush;
- } else {
- rop3_src_brush = rop3_src;
- }
-
- if (rop3_bits & SPICE_ROPD_OP_PUT) {
- rop3 = rop3_src_brush;
- }
- if (rop3_bits & SPICE_ROPD_OP_OR) {
- rop3 = rop3_src_brush | rop3_dest;
- }
- if (rop3_bits & SPICE_ROPD_OP_AND) {
- rop3 = rop3_src_brush & rop3_dest;
- }
- if (rop3_bits & SPICE_ROPD_OP_XOR) {
- rop3 = rop3_src_brush ^ rop3_dest;
- }
- if (rop3_bits & SPICE_ROPD_INVERS_RES) {
- rop3 = ~rop3_dest;
- }
-
- if (rop3_bits & SPICE_ROPD_OP_BLACKNESS || rop3_bits & SPICE_ROPD_OP_WHITENESS ||
- rop3_bits & SPICE_ROPD_OP_INVERS) {
- CANVAS_ERROR("invalid rop3 type");
- }
- return rop3;
-}
-
-uint8_t calc_rop3_src_brush(uint16_t rop3_bits)
-{
- uint8_t rop3 = 0;
- uint8_t rop3_src = _rop3_src;
- uint8_t rop3_brush = _rop3_brush;
-
- if (rop3_bits & SPICE_ROPD_INVERS_SRC) {
- rop3_src = ~rop3_src;
- }
- if (rop3_bits & SPICE_ROPD_INVERS_BRUSH) {
- rop3_brush = ~rop3_brush;
- }
-
- if (rop3_bits & SPICE_ROPD_OP_OR) {
- rop3 = rop3_src | rop3_brush;
- }
- if (rop3_bits & SPICE_ROPD_OP_AND) {
- rop3 = rop3_src & rop3_brush;
- }
- if (rop3_bits & SPICE_ROPD_OP_XOR) {
- rop3 = rop3_src ^ rop3_brush;
- }
-
- return rop3;
-}
-
-static struct BitmapData get_mask_bitmap(struct GdiCanvas *canvas, struct SpiceQMask *mask)
-{
- GdiCanvas *gdi_surface;
- pixman_image_t *surface;
- struct BitmapData bitmap;
- PixmanData *pixman_data;
-
- bitmap.hbitmap = NULL;
- if (!mask->bitmap) {
- return bitmap;
- }
-
- gdi_surface = (GdiCanvas *)canvas_get_surface_mask(&canvas->base, mask->bitmap);
- if (gdi_surface) {
- HBITMAP _bitmap;
-
- _bitmap = (HBITMAP)GetCurrentObject(gdi_surface->dc, OBJ_BITMAP);
- if (!_bitmap) {
- CANVAS_ERROR ("GetCurrentObject failed");
- }
- bitmap.dc = gdi_surface->dc;
- bitmap.hbitmap = _bitmap;
- bitmap.prev_hbitmap = (HBITMAP)0;
- bitmap.cache = 0;
- bitmap.from_surface = 1;
- } else {
-
- if (!(surface = canvas_get_mask(&canvas->base, mask, NULL))) {
- return bitmap;
- }
-
- pixman_data = (PixmanData *)pixman_image_get_destroy_data (surface);
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- bitmap.dc = create_compatible_dc();
- bitmap.prev_hbitmap = (HBITMAP)SelectObject(bitmap.dc, pixman_data->bitmap);
- bitmap.hbitmap = pixman_data->bitmap;
- ReleaseMutex(pixman_data->mutex);
- bitmap.cache = 1;
- } else if (!create_bitmap_from_pixman(&bitmap.hbitmap, &bitmap.prev_hbitmap, &bitmap.dc,
- surface, 0)) {
- bitmap.hbitmap = NULL;
- } else {
- bitmap.cache = 0;
- }
-
- bitmap.from_surface = 0;
- }
-
- bitmap.flags = mask->flags;
- bitmap.pos = mask->pos;
-
- return bitmap;
-}
-
-static void gdi_draw_bitmap(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
- HDC src_dc, struct BitmapData *bitmapmask, uint32_t rop3_val)
-{
- uint32_t rast_oper;
-
- rast_oper = raster_ops[rop3_val];
-
- if (!bitmapmask || !bitmapmask->hbitmap) {
- if ((dest->right - dest->left) == (src->right - src->left) &&
- (dest->bottom - dest->top) == (src->bottom - src->top)) {
- if (!BitBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
- dest->bottom - dest->top, src_dc, src->left, src->top, rast_oper)) {
- CANVAS_ERROR("BitBlt failed");
- }
- } else {
- if (!StretchBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
- dest->bottom - dest->top, src_dc, src->left, src->top,
- src->right - src->left, src->bottom - src->top, rast_oper)) {
- CANVAS_ERROR("StretchBlt failed");
- }
- }
- } else {
- rast_oper = MAKEROP4(rast_oper, raster_ops[_rop3_dest]);
-
- if (!MaskBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
- dest->bottom - dest->top, src_dc, src->left, src->top,
- bitmapmask->hbitmap, bitmapmask->pos.x, bitmapmask->pos.y,
- rast_oper)) {
- CANVAS_ERROR("MaskBlt failed");
- }
- }
-}
-
-static void gdi_draw_bitmap_redrop(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
- HDC src_dc, struct BitmapData *bitmapmask,
- uint16_t rop, int brush)
-{
- uint32_t rop3_val;
-
- rop3_val = calc_rop3(rop, brush);
- gdi_draw_bitmap(dest_dc, src, dest, src_dc, bitmapmask, rop3_val);
-}
-
-static void free_mask(struct BitmapData *bitmap)
-{
- if (bitmap->hbitmap) {
- if (!bitmap->from_surface) {
- release_bitmap(bitmap->dc, bitmap->hbitmap, bitmap->prev_hbitmap, bitmap->cache);
- }
- }
-}
-
-static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
- SpiceString *str, int n, SpiceRect *dest,
- SpiceRect *src, SpiceBrush *brush)
-{
- pixman_image_t *surface;
- struct BitmapData bitmap;
- SpicePoint pos;
- int dest_stride;
- uint8_t *bitmap_data;
- HBRUSH prev_hbrush;
- HBRUSH hbrush;
- RecurciveMutex *brush_lock;
-
- bitmap.hbitmap = (HBITMAP)1;
- if (!(surface = canvas_get_str_mask(&canvas->base, str, n, &pos))) {
- CANVAS_ERROR("unable to canvas_get_str_mask");
- return;
- }
-
- bitmap.from_surface = 0;
- bitmap.cache = 0;
- bitmap_data = create_bitmap(&bitmap.hbitmap, &bitmap.prev_hbitmap,
- &bitmap.dc, NULL,
- pixman_image_get_width(surface),
- pixman_image_get_height(surface),
- pixman_image_get_stride(surface), 32, 0);
-
- if (!bitmap_data) {
- return;
- }
-
- bitmap.flags = 0;
- bitmap.pos.x = 0;
- bitmap.pos.y = 0;
-
- dest->left = pos.x;
- dest->top = pos.y;
- dest->right = pos.x + pixman_image_get_width(surface);
- dest->bottom = pos.y + pixman_image_get_height(surface);
- src->left = 0;
- src->top = 0;
- src->right = pixman_image_get_width(surface);
- src->bottom = pixman_image_get_height(surface);
-
- dest_stride = pixman_image_get_width(surface);
- switch (n) {
- case 1:
- dest_stride = dest_stride / 8;
- break;
- case 4:
- dest_stride = dest_stride / 2;
- break;
- case 32:
- dest_stride = dest_stride * 4;
- break;
- default:
- CANVAS_ERROR("unsupported bitmap bits size");
- }
- dest_stride = dest_stride + 3;
- dest_stride = dest_stride & ~3;
-
- hbrush = get_brush(canvas, brush, &brush_lock);
- prev_hbrush = set_brush(bitmap.dc, hbrush, brush);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap(bitmap.dc, src, src, bitmap.dc, NULL, _rop3_brush);
- } else {
- gdi_draw_bitmap(bitmap.dc, src, src, bitmap.dc, NULL, _rop3_brush);
- }
-
- unset_brush(bitmap.dc, prev_hbrush);
-
- copy_bitmap_alpha((uint8_t *)pixman_image_get_data(surface),
- pixman_image_get_height(surface),
- pixman_image_get_width(surface),
- pixman_image_get_stride(surface),
- bitmap_data, dest_stride, n);
-
- BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
-
- RecurciveLock lock(*canvas->lock);
- AlphaBlend(canvas->dc, dest->left, dest->top, dest->right - dest->left,
- dest->bottom - dest->top, bitmap.dc, src->left, src->top,
- src->right - src->left, src->bottom - src->top, bf);
-
- free_mask(&bitmap);
-}
-
-static void gdi_draw_image(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
- pixman_image_t *image, struct BitmapData *bitmapmask, uint16_t rop,
- int rotate)
-{
- HDC dc;
- HBITMAP bitmap;
- HBITMAP prev_bitmap;
-
- create_bitmap_from_pixman(&bitmap, &prev_bitmap, &dc, image, rotate);
-
- gdi_draw_bitmap_redrop(dest_dc, src, dest, dc, bitmapmask, rop, 0);
-
- release_bitmap(dc, bitmap, prev_bitmap, 0);
-}
-
-static void gdi_draw_image_rop3(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
- pixman_image_t *image, struct BitmapData *bitmapmask, uint8_t rop3,
- int rotate)
-{
- HDC dc;
- HBITMAP bitmap;
- HBITMAP prev_bitmap;
-
- create_bitmap_from_pixman(&bitmap, &prev_bitmap, &dc, image, rotate);
-
- gdi_draw_bitmap(dest_dc, src, dest, dc, bitmapmask, rop3);
-
- release_bitmap(dc, bitmap, prev_bitmap, 0);
-}
-
-static void gdi_canvas_draw_fill(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- HBRUSH prev_hbrush;
- HBRUSH brush;
- struct BitmapData bitmapmask;
- RecurciveMutex *brush_lock;
-
- RecurciveLock lock(*canvas->lock);
-
- if (!(brush = get_brush(canvas, &fill->brush, &brush_lock))) {
- CANVAS_ERROR("no braash");
- return;
- }
-
- bitmapmask = get_mask_bitmap(canvas, &fill->mask);
-
- set_clip(canvas, clip);
- prev_hbrush = set_brush(canvas->dc, brush, &fill->brush);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
- fill->rop_descriptor, fill->brush.type != SPICE_BRUSH_TYPE_NONE);
- } else {
- gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
- fill->rop_descriptor, fill->brush.type != SPICE_BRUSH_TYPE_NONE);
- }
-
- free_mask(&bitmapmask);
- unset_brush(canvas->dc, prev_hbrush);
-}
-
-static void gdi_canvas_draw_copy(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- GdiCanvas *gdi_surface;
- pixman_image_t *surface;
- struct BitmapData bitmapmask;
- PixmanData *pixman_data;
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, copy->src_bitmap);
- if (gdi_surface) {
- RecurciveLock lock(*canvas->lock);
- RecurciveLock s_lock(*gdi_surface->lock);
- bitmapmask = get_mask_bitmap(canvas, ©->mask);
- set_scale_mode(canvas, copy->scale_mode);
- set_clip(canvas, clip);
- gdi_draw_bitmap_redrop(canvas->dc, ©->src_area, bbox, gdi_surface->dc,
- &bitmapmask, copy->rop_descriptor, 0);
- } else {
- surface = canvas_get_image(&canvas->base, copy->src_bitmap, FALSE);
- pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
-
- RecurciveLock lock(*canvas->lock);
- bitmapmask = get_mask_bitmap(canvas, ©->mask);
- set_scale_mode(canvas, copy->scale_mode);
- set_clip(canvas, clip);
-
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- HDC dc;
- HBITMAP prev_bitmap;
-
- dc = create_compatible_dc();
- prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
- gdi_draw_bitmap_redrop(canvas->dc, ©->src_area, bbox, dc,
- &bitmapmask, copy->rop_descriptor, 0);
- SelectObject(dc, prev_bitmap);
- DeleteObject(dc);
- ReleaseMutex(pixman_data->mutex);
- } else {
- gdi_draw_image(canvas->dc, ©->src_area, bbox, surface, &bitmapmask,
- copy->rop_descriptor, 0);
- }
-
- pixman_image_unref(surface);
- }
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_put_image(SpiceCanvas *spice_canvas, HDC dc, const SpiceRect *dest, const uint8_t *src_data,
- uint32_t src_width, uint32_t src_height, int src_stride,
- const QRegion *clip)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- SpiceRect src;
- src.top = 0;
- src.bottom = src_height;
- src.left = 0;
- src.right = src_width;
- int num_rects;
- pixman_box32_t *rects;
-
- RecurciveLock lock(*canvas->lock);
- set_scale_mode(canvas, SPICE_IMAGE_SCALE_MODE_NEAREST);
- if (clip) {
- rects = pixman_region32_rectangles((pixman_region32_t*)clip, &num_rects);
- if (num_rects == 0) {
- return;
- } else {
- HRGN main_hrgn;
- int i;
-
- main_hrgn = CreateRectRgn(rects[0].x1, rects[0].y1, rects[0].x2,
- rects[0].y2);
- if (!main_hrgn) {
- return;
- }
-
- for (i = 1; i < num_rects; i++) {
- HRGN combaine_hrgn;
-
- combaine_hrgn = CreateRectRgn(rects[i].x1, rects[i].y1,
- rects[i].x2,
- rects[i].y2);
- if (!combaine_hrgn) {
- CANVAS_ERROR("CreateRectRgn failed");
- DeleteObject(main_hrgn);
- return;
- }
- if (!CombineRgn(main_hrgn, main_hrgn, combaine_hrgn, RGN_OR)) {
- CANVAS_ERROR("CombineRgn failed in put_image");
- return;
- }
- DeleteObject(combaine_hrgn);
- }
- if (SelectClipRgn(canvas->dc, main_hrgn) == ERROR) {
- CANVAS_ERROR("SelectClipRgn failed in put_image");
- DeleteObject(main_hrgn);
- return;
- }
- DeleteObject(main_hrgn);
- }
- } else {
- SelectClipRgn(canvas->dc, NULL);
- }
-
- if (dc) {
- gdi_draw_bitmap_redrop(canvas->dc, &src, dest, dc,
- NULL, SPICE_ROPD_OP_PUT, 0);
- } else {
- pixman_image_t *image = pixman_image_create_bits(PIXMAN_a8r8g8b8, src_width, src_height,
- (uint32_t *)src_data, src_stride);
- gdi_draw_image(canvas->dc, &src, dest, image, NULL, SPICE_ROPD_OP_PUT, 0);
- pixman_image_unref(image);
- }
-}
-
-static void gdi_draw_bitmap_transparent(GdiCanvas *canvas, HDC dest_dc, const SpiceRect *src,
- const SpiceRect *dest, HDC src_dc, uint32_t color)
-{
- TransparentBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
- dest->bottom - dest->top, src_dc, src->left, src->top,
- src->right - src->left, src->bottom - src->top,
- RGB(((uint8_t*)&color)[2], ((uint8_t*)&color)[1], ((uint8_t*)&color)[0]));
-}
-
-static void gdi_draw_image_transparent(GdiCanvas *canvas, HDC dest_dc, const SpiceRect *src,
- const SpiceRect *dest, pixman_image_t *image,
- uint32_t color, int rotate)
-{
- HDC dc;
- HBITMAP bitmap;
- HBITMAP prev_bitmap;
-
- create_bitmap_from_pixman(&bitmap, &prev_bitmap, &dc, image, rotate);
-
- gdi_draw_bitmap_transparent(canvas, dest_dc, src, dest, dc, color);
-
- release_bitmap(dc, bitmap, prev_bitmap, 0);
-}
-
-static void gdi_canvas_draw_transparent(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip,
- SpiceTransparent* transparent)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- GdiCanvas *gdi_surface;
- pixman_image_t *surface;
- PixmanData *pixman_data;
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, transparent->src_bitmap);
- if (gdi_surface) {
- RecurciveLock lock(*canvas->lock);
- RecurciveLock s_lock(*gdi_surface->lock);
- set_clip(canvas, clip);
- gdi_draw_bitmap_transparent(canvas, canvas->dc, &transparent->src_area, bbox,
- gdi_surface->dc, transparent->true_color);
- } else {
- surface = canvas_get_image(&canvas->base, transparent->src_bitmap, FALSE);
- pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
- RecurciveLock lock(*canvas->lock);
- set_clip(canvas, clip);
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- HDC dc;
- HBITMAP prev_bitmap;
-
- dc = create_compatible_dc();
- prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
- gdi_draw_bitmap_transparent(canvas, canvas->dc, &transparent->src_area, bbox, dc,
- transparent->true_color);
-
- SelectObject(dc, prev_bitmap);
- DeleteObject(dc);
- ReleaseMutex(pixman_data->mutex);
- } else {
- gdi_draw_image_transparent(canvas, canvas->dc, &transparent->src_area, bbox, surface,
- transparent->true_color, 0);
- }
-
- pixman_image_unref(surface);
- }
-}
-
-static void gdi_draw_bitmap_alpha(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
- HDC src_dc, uint8_t alpha, int use_bitmap_alpha)
-{
- BLENDFUNCTION bf;
-
- bf.BlendOp = AC_SRC_OVER;
- bf.BlendFlags = 0;
- bf.SourceConstantAlpha = alpha;
-
- if (use_bitmap_alpha) {
- bf.AlphaFormat = AC_SRC_ALPHA;
- } else {
- bf.AlphaFormat = 0;
- }
-
- if (!AlphaBlend(dest_dc, dest->left, dest->top, dest->right - dest->left,
- dest->bottom - dest->top, src_dc, src->left, src->top,
- src->right - src->left, src->bottom - src->top, bf)) {
- CANVAS_ERROR("AlphaBlend failed");
- }
-}
-
-static void gdi_draw_image_alpha(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
- pixman_image_t *image, uint8_t alpha,
- int rotate, int use_bitmap_alpha)
-{
- HDC dc;
- HBITMAP bitmap;
- HBITMAP prev_bitmap;
-
- create_bitmap_from_pixman(&bitmap, &prev_bitmap, &dc, image, rotate);
-
- gdi_draw_bitmap_alpha(dest_dc, src, dest, dc, alpha, use_bitmap_alpha);
-
- release_bitmap(dc, bitmap, prev_bitmap, 0);
-}
-
-static void gdi_canvas_draw_alpha_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlend* alpha_blend)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- GdiCanvas *gdi_surface;
- pixman_image_t *surface;
- PixmanData *pixman_data;
- int use_bitmap_alpha;
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, alpha_blend->src_bitmap);
- if (gdi_surface) {
- RecurciveLock lock(*canvas->lock);
- RecurciveLock s_lock(*gdi_surface->lock);
- set_clip(canvas, clip);
- use_bitmap_alpha = alpha_blend->alpha_flags & SPICE_ALPHA_FLAGS_SRC_SURFACE_HAS_ALPHA;
- gdi_draw_bitmap_alpha(canvas->dc, &alpha_blend->src_area, bbox, gdi_surface->dc,
- alpha_blend->alpha, use_bitmap_alpha);
- } else {
- surface = canvas_get_image(&canvas->base, alpha_blend->src_bitmap, TRUE);
- use_bitmap_alpha = pixman_image_get_depth(surface) == 32;
- pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
-
- RecurciveLock lock(*canvas->lock);
- set_clip(canvas, clip);
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- HDC dc;
- HBITMAP prev_bitmap;
-
- dc = create_compatible_dc();
- prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
- gdi_draw_bitmap_alpha(canvas->dc, &alpha_blend->src_area, bbox, dc, alpha_blend->alpha,
- use_bitmap_alpha);
- SelectObject(dc, prev_bitmap);
- DeleteObject(dc);
- ReleaseMutex(pixman_data->mutex);
- } else {
- gdi_draw_image_alpha(canvas->dc, &alpha_blend->src_area, bbox, surface,
- alpha_blend->alpha, 0, use_bitmap_alpha);
- }
-
- pixman_image_unref(surface);
- }
-}
-
-static void gdi_canvas_draw_opaque(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
-{
- GdiCanvas *gdi_surface;
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- pixman_image_t *surface;
- struct BitmapData bitmapmask;
- PixmanData *pixman_data;
- HBRUSH prev_hbrush;
- HBRUSH hbrush;
- uint8_t rop3;
- RecurciveMutex *brush_lock;
-
- rop3 = calc_rop3_src_brush(opaque->rop_descriptor);
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, opaque->src_bitmap);
- if (gdi_surface) {
- RecurciveLock lock(*canvas->lock);
- RecurciveLock s_lock(*gdi_surface->lock);
- bitmapmask = get_mask_bitmap(canvas, &opaque->mask);
- hbrush = get_brush(canvas, &opaque->brush, &brush_lock);
- set_scale_mode(canvas, opaque->scale_mode);
- set_clip(canvas, clip);
- prev_hbrush = set_brush(canvas->dc, hbrush, &opaque->brush);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, gdi_surface->dc, &bitmapmask, rop3);
- } else {
- gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, gdi_surface->dc, &bitmapmask, rop3);
- }
- unset_brush(canvas->dc, prev_hbrush);
- } else {
- surface = canvas_get_image(&canvas->base, opaque->src_bitmap, FALSE);
- pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
-
- RecurciveLock lock(*canvas->lock);
- bitmapmask = get_mask_bitmap(canvas, &opaque->mask);
- hbrush = get_brush(canvas, &opaque->brush, &brush_lock);
- set_scale_mode(canvas, opaque->scale_mode);
- set_clip(canvas, clip);
- prev_hbrush = set_brush(canvas->dc, hbrush, &opaque->brush);
-
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- HDC dc;
- HBITMAP prev_bitmap;
-
- dc = create_compatible_dc();
- prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, dc, &bitmapmask, rop3);
- } else {
- gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, dc, &bitmapmask, rop3);
- }
- SelectObject(dc, prev_bitmap);
- DeleteObject(dc);
- ReleaseMutex(pixman_data->mutex);
- } else {
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_image_rop3(canvas->dc, &opaque->src_area, bbox, surface, &bitmapmask, rop3, 0);
- } else {
- gdi_draw_image_rop3(canvas->dc, &opaque->src_area, bbox, surface, &bitmapmask, rop3, 0);
- }
- }
- unset_brush(canvas->dc, prev_hbrush);
- pixman_image_unref(surface);
- }
-
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_draw_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
-{
- GdiCanvas *gdi_surface;
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- pixman_image_t *surface;
- struct BitmapData bitmapmask;
- PixmanData *pixman_data;
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, blend->src_bitmap);
- if (gdi_surface) {
- RecurciveLock lock(*canvas->lock);
- RecurciveLock s_lock(*gdi_surface->lock);
- bitmapmask = get_mask_bitmap(canvas, &blend->mask);
- set_scale_mode(canvas, blend->scale_mode);
- set_clip(canvas, clip);
- gdi_draw_bitmap_redrop(canvas->dc, &blend->src_area, bbox, gdi_surface->dc,
- &bitmapmask, blend->rop_descriptor, 0);
- } else {
- surface = canvas_get_image(&canvas->base, blend->src_bitmap, FALSE);
- pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
-
- RecurciveLock lock(*canvas->lock);
- bitmapmask = get_mask_bitmap(canvas, &blend->mask);
- set_scale_mode(canvas, blend->scale_mode);
- set_clip(canvas, clip);
-
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- HDC dc;
- HBITMAP prev_bitmap;
-
- dc = create_compatible_dc();
- prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
- gdi_draw_bitmap_redrop(canvas->dc, &blend->src_area, bbox, dc,
- &bitmapmask, blend->rop_descriptor, 0);
- SelectObject(dc, prev_bitmap);
- DeleteObject(dc);
- ReleaseMutex(pixman_data->mutex);
- } else {
- gdi_draw_image(canvas->dc, &blend->src_area, bbox, surface,
- &bitmapmask, blend->rop_descriptor, 0);
- }
-
- pixman_image_unref(surface);
- }
-
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_draw_blackness(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- struct BitmapData bitmapmask;
-
- RecurciveLock lock(*canvas->lock);
- bitmapmask = get_mask_bitmap(canvas, &blackness->mask);
- set_clip(canvas, clip);
- gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0x0);
-
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_draw_invers(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- struct BitmapData bitmapmask;
-
- RecurciveLock lock(*canvas->lock);
- bitmapmask = get_mask_bitmap(canvas, &invers->mask);
- set_clip(canvas, clip);
- gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0x55);
-
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_draw_whiteness(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- struct BitmapData bitmapmask;
-
- RecurciveLock lock(*canvas->lock);
- bitmapmask = get_mask_bitmap(canvas, &whiteness->mask);
- set_clip(canvas, clip);
- gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0xff);
-
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
-{
- GdiCanvas *gdi_surface;
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- pixman_image_t *surface;
- struct BitmapData bitmapmask;
- HBRUSH prev_hbrush;
- HBRUSH hbrush;
- PixmanData *pixman_data;
- RecurciveMutex *brush_lock;
-
- gdi_surface = (GdiCanvas *)canvas_get_surface(&canvas->base, rop3->src_bitmap);
- if (gdi_surface) {
- RecurciveLock lock(*canvas->lock);
- RecurciveLock s_lock(*gdi_surface->lock);
- hbrush = get_brush(canvas, &rop3->brush, &brush_lock);
- bitmapmask = get_mask_bitmap(canvas, &rop3->mask);
- set_scale_mode(canvas, rop3->scale_mode);
- set_clip(canvas, clip);
- prev_hbrush = set_brush(canvas->dc, hbrush, &rop3->brush);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, gdi_surface->dc,
- &bitmapmask, rop3->rop3);
- } else {
- gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, gdi_surface->dc,
- &bitmapmask, rop3->rop3);
- }
- unset_brush(canvas->dc, prev_hbrush);
- } else {
- surface = canvas_get_image(&canvas->base, rop3->src_bitmap, FALSE);
- pixman_data = (PixmanData *)pixman_image_get_destroy_data(surface);
- RecurciveLock lock(*canvas->lock);
- hbrush = get_brush(canvas, &rop3->brush, &brush_lock);
- bitmapmask = get_mask_bitmap(canvas, &rop3->mask);
- set_scale_mode(canvas, rop3->scale_mode);
- set_clip(canvas, clip);
- prev_hbrush = set_brush(canvas->dc, hbrush, &rop3->brush);
-
- if (pixman_data && (WaitForSingleObject(pixman_data->mutex, INFINITE) != WAIT_FAILED)) {
- HDC dc;
- HBITMAP prev_bitmap;
-
- dc = create_compatible_dc();
- prev_bitmap = (HBITMAP)SelectObject(dc, pixman_data->bitmap);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, dc,
- &bitmapmask, rop3->rop3);
- } else {
- gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, dc,
- &bitmapmask, rop3->rop3);
- }
- SelectObject(dc, prev_bitmap);
- DeleteObject(dc);
- ReleaseMutex(pixman_data->mutex);
- } else {
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_image_rop3(canvas->dc, &rop3->src_area, bbox, surface, &bitmapmask, rop3->rop3, 0);
- } else {
- gdi_draw_image_rop3(canvas->dc, &rop3->src_area, bbox, surface, &bitmapmask, rop3->rop3, 0);
- }
- }
-
- unset_brush(canvas->dc, prev_hbrush);
- pixman_image_unref(surface);
- }
-
- free_mask(&bitmapmask);
-}
-
-static void gdi_canvas_copy_bits(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- RecurciveLock lock(*canvas->lock);
-
- set_clip(canvas, clip);
-
- BitBlt(canvas->dc, bbox->left, bbox->top, bbox->right - bbox->left,
- bbox->bottom - bbox->top, canvas->dc, src_pos->x, src_pos->y, SRCCOPY);
-}
-
-static void gdi_canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- SpiceString *str;
- RecurciveMutex *brush_lock;
-
- RecurciveLock lock(*canvas->lock);
- set_clip(canvas, clip);
- lock.unlock();
-
- if (!rect_is_empty(&text->back_area)) {
- HBRUSH prev_hbrush;
- HBRUSH hbrush;
-
- RecurciveLock lock(*canvas->lock);
- hbrush = get_brush(canvas, &text->back_brush, &brush_lock);
- prev_hbrush = set_brush(canvas->dc, hbrush, &text->back_brush);
- if (brush_lock) {
- RecurciveLock b_lock(*brush_lock);
- gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, NULL,
- text->back_mode, 1);
- } else {
- gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, NULL,
- text->back_mode, 1);
- }
- unset_brush(canvas->dc, prev_hbrush);
- }
-
- str = (SpiceString *)SPICE_GET_ADDRESS(text->str);
-
- if (str->flags & SPICE_STRING_FLAGS_RASTER_A1) {
- SpiceRect dest;
- SpiceRect src;
-
- draw_str_mask_bitmap(canvas, str, 1, &dest, &src, &text->fore_brush);
- } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A4) {
- SpiceRect dest;
- SpiceRect src;
-
- draw_str_mask_bitmap(canvas, str, 4, &dest, &src, &text->fore_brush);
- } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
- WARN("untested path A8 glyphs, doing nothing");
- if (0) {
- SpiceRect dest;
- SpiceRect src;
-
- draw_str_mask_bitmap(canvas, str, 8, &dest, &src, &text->fore_brush);
- }
- } else {
- WARN("untested path vector glyphs, doing nothing");
- if (0) {
- }
- }
-}
-
-static uint32_t *gdi_get_userstyle(GdiCanvas *canvas, uint8_t nseg, SPICE_FIXED28_4* style, int start_is_gap)
-{
- uint32_t *local_style;
- int i;
-
- if (nseg == 0) {
- CANVAS_ERROR("bad nseg");
- }
- local_style = spice_new(uint32_t , nseg);
-
- if (start_is_gap) {
- local_style[nseg - 1] = (uint32_t)fix_to_double(*style);
- style++;
-
- for (i = 0; i < nseg - 1; i++, style++) {
- local_style[i] = (uint32_t)fix_to_double(*style);
- }
- } else {
- for (i = 0; i < nseg; i++, style++) {
- local_style[i] = (uint32_t)fix_to_double(*style);
- }
- }
-
- return local_style;
-}
-
-static void gdi_canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- HPEN hpen;
- HPEN prev_hpen;
- LOGBRUSH logbrush;
- uint32_t *user_style = NULL;
- pixman_image_t *surface = NULL;
-
- if (stroke->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
- surface = canvas_get_image(&canvas->base, stroke->brush.u.pattern.pat, FALSE);
- }
-
- RecurciveLock lock(*canvas->lock);
- set_clip(canvas, clip);
-
- switch (stroke->fore_mode) {
- case SPICE_ROPD_OP_WHITENESS:
- SetROP2(canvas->dc, R2_WHITE); //0
- break;
- case SPICE_ROPD_OP_BLACKNESS:
- SetROP2(canvas->dc, R2_BLACK); //1
- break;
- case SPICE_ROPD_OP_INVERS:
- SetROP2(canvas->dc, R2_NOT); //Dn
- break;
- case SPICE_ROPD_OP_PUT:
- SetROP2(canvas->dc, R2_COPYPEN); //P
- break;
- case SPICE_ROPD_OP_OR:
- SetROP2(canvas->dc, R2_MERGEPEN); //DPo
- break;
- case SPICE_ROPD_OP_XOR:
- SetROP2(canvas->dc, R2_XORPEN); //DPx
- break;
- case SPICE_ROPD_OP_AND:
- SetROP2(canvas->dc, R2_MASKPEN); //DPa
- break;
- case SPICE_ROPD_INVERS_BRUSH | SPICE_ROPD_OP_PUT: //Pn
- SetROP2(canvas->dc, R2_NOTCOPYPEN);
- break;
- case SPICE_ROPD_OP_XOR | SPICE_ROPD_INVERS_RES:
- SetROP2(canvas->dc, R2_NOTXORPEN); //DPxn
- break;
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_RES:
- SetROP2(canvas->dc, R2_NOTMERGEPEN); //DPon
- break;
- case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_RES:
- SetROP2(canvas->dc, R2_NOTMASKPEN); //DPan
- break;
- case SPICE_ROPD_INVERS_DEST | SPICE_ROPD_OP_AND:
- SetROP2(canvas->dc, R2_MASKPENNOT); //PDna
- break;
- case SPICE_ROPD_INVERS_BRUSH | SPICE_ROPD_OP_AND:
- SetROP2(canvas->dc, R2_MASKNOTPEN); //DPna
- break;
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_BRUSH:
- SetROP2(canvas->dc, R2_MERGENOTPEN); //DPno
- break;
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_DEST:
- SetROP2(canvas->dc, R2_MERGEPENNOT); //PDno
- break;
- default:
- SetROP2(canvas->dc, R2_NOP); //D
- }
-
-
- if (stroke->brush.type == SPICE_BRUSH_TYPE_SOLID) {
- logbrush.lbStyle = BS_SOLID | DIB_RGB_COLORS;
- logbrush.lbHatch = 0;
- logbrush.lbColor = get_color_ref(canvas, stroke->brush.u.color);
- } else if (stroke->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
-#if 0
- struct {
- BITMAPINFO inf;
- RGBQUAD palette[255];
- } bitmap_info;
- GdiImage image;
-#endif
- //CANVAS_ERROR("untested path stroke brush with pattern");
-#if 0
- ASSERT(surface)
- surface_to_image(surface, &image);
-
- memset(&bitmap_info, 0, sizeof(bitmap_info));
- bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
- bitmap_info.inf.bmiHeader.biWidth = image.width;
- if (image.stride < 0) {
- bitmap_info.inf.bmiHeader.biHeight = image.height;
- } else {
- bitmap_info.inf.bmiHeader.biHeight = -image.height;
- }
- bitmap_info.inf.bmiHeader.biPlanes = 1;
- bitmap_info.inf.bmiHeader.biBitCount = 32;
- bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
-
- if (image.stride < 0) {
- logbrush.lbHatch = (LONG)GlobalAlloc(GMEM_MOVEABLE,
- image.height * -image.stride + sizeof(BITMAPINFO));
- if (!logbrush.lbHatch) {
- CANVAS_ERROR("GlobalAlloc failed");
- }
- copy_bitmap(image.pixels - (image.height - 1) * -image.stride,
- image.height, -image.stride,
- (uint8_t *)logbrush.lbHatch, image.width);
- } else {
- logbrush.lbHatch = (LONG)GlobalAlloc(GMEM_MOVEABLE,
- image.height * image.stride + sizeof(BITMAPINFO));
- if (!logbrush.lbHatch) {
- CANVAS_ERROR("GlobalAlloc failed");
- }
- copy_bitmap(image.pixels, image.height, image.stride,
- (uint8_t *)logbrush.lbHatch, image.width);
- }
-
- memcpy((void *)logbrush.lbHatch, &bitmap_info.inf, sizeof(BITMAPINFO));
-
- logbrush.lbStyle = BS_DIBPATTERN | DIB_RGB_COLORS;
- logbrush.lbColor = 0;
-#endif
- pixman_image_unref(surface);
- }
-
- if (stroke->attr.flags & SPICE_LINE_FLAGS_STYLED) {
- user_style = gdi_get_userstyle(canvas, stroke->attr.style_nseg,
- stroke->attr.style,
- !!(stroke->attr.flags & SPICE_LINE_FLAGS_START_WITH_GAP));
- hpen = ExtCreatePen(PS_COSMETIC | PS_USERSTYLE,
- 1,
- &logbrush, stroke->attr.style_nseg, (DWORD *)user_style);
- } else {
- hpen = ExtCreatePen(PS_COSMETIC,
- 1,
- &logbrush, 0, NULL);
- }
- prev_hpen = (HPEN)SelectObject(canvas->dc, hpen);
-
- set_path(canvas, stroke->path);
-
- StrokePath(canvas->dc);
-
- SelectObject(canvas->dc, prev_hpen);
- DeleteObject(hpen);
-
-#if 0
- if (stroke->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
- GlobalFree((HGLOBAL)logbrush.lbHatch);
- }
-#endif
-
- free(user_style);
-}
-
-static void gdi_canvas_clear(SpiceCanvas *spice_canvas)
-{
-}
-
-static void gdi_canvas_destroy(SpiceCanvas *spice_canvas)
-{
- GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
- if (!canvas) {
- return;
- }
- canvas_base_destroy(&canvas->base);
- free(canvas);
-}
-
-static int need_init = 1;
-static SpiceCanvasOps gdi_canvas_ops;
-
-SpiceCanvas *gdi_canvas_create(int width, int height,
- HDC dc, RecurciveMutex* lock, uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- )
-{
- GdiCanvas *canvas;
-
- if (need_init) {
- return NULL;
- }
- canvas = spice_new0(GdiCanvas, 1);
- canvas_base_init(&canvas->base, &gdi_canvas_ops,
- width, height, format,
-#ifdef SW_CANVAS_CACHE
- bits_cache,
- palette_cache,
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- bits_cache,
-#endif
- surfaces,
- glz_decoder,
- jpeg_decoder,
- zlib_decoder);
- canvas->dc = dc;
- canvas->lock = lock;
- return (SpiceCanvas *)canvas;
-}
-
-void gdi_canvas_init(void) //unsafe global function
-{
- if (!need_init) {
- return;
- }
- need_init = 0;
-
- canvas_base_init_ops(&gdi_canvas_ops);
- gdi_canvas_ops.draw_fill = gdi_canvas_draw_fill;
- gdi_canvas_ops.draw_copy = gdi_canvas_draw_copy;
- gdi_canvas_ops.draw_opaque = gdi_canvas_draw_opaque;
- gdi_canvas_ops.copy_bits = gdi_canvas_copy_bits;
- gdi_canvas_ops.draw_text = gdi_canvas_draw_text;
- gdi_canvas_ops.draw_stroke = gdi_canvas_draw_stroke;
- gdi_canvas_ops.draw_rop3 = gdi_canvas_draw_rop3;
- gdi_canvas_ops.draw_blend = gdi_canvas_draw_blend;
- gdi_canvas_ops.draw_blackness = gdi_canvas_draw_blackness;
- gdi_canvas_ops.draw_whiteness = gdi_canvas_draw_whiteness;
- gdi_canvas_ops.draw_invers = gdi_canvas_draw_invers;
- gdi_canvas_ops.draw_transparent = gdi_canvas_draw_transparent;
- gdi_canvas_ops.draw_alpha_blend = gdi_canvas_draw_alpha_blend;
- gdi_canvas_ops.put_image = gdi_canvas_put_image;
- gdi_canvas_ops.clear = gdi_canvas_clear;
- gdi_canvas_ops.destroy = gdi_canvas_destroy;
-
- rop3_init();
-}
diff --git a/common/gdi_canvas.h b/common/gdi_canvas.h
deleted file mode 100644
index f92c042..0000000
--- a/common/gdi_canvas.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H__GDI_CANVAS
-#define _H__GDI_CANVAS
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This header shouldn't be included directly"
-#endif
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pixman_utils.h"
-#include "canvas_base.h"
-#include "region.h"
-
-SpiceCanvas *gdi_canvas_create(int width, int height,
- HDC dc, class RecurciveMutex *lock, uint32_t format,
- SpiceImageCache *bits_cache,
- SpicePaletteCache *palette_cache,
- SpiceImageSurfaces *surfaces,
- SpiceGlzDecoder *glz_decoder,
- SpiceJpegDecoder *jpeg_decoder,
- SpiceZlibDecoder *zlib_decoder);
-
-void gdi_canvas_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/gl_canvas.c b/common/gl_canvas.c
deleted file mode 100644
index ffc6b52..0000000
--- a/common/gl_canvas.c
+++ /dev/null
@@ -1,906 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This file shouldn't be compiled directly"
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "quic.h"
-#include "rop3.h"
-#include "region.h"
-
-#define GL_CANVAS
-#include "canvas_base.c"
-
-typedef struct GLCanvas GLCanvas;
-
-struct GLCanvas {
- CanvasBase base;
- GLCCtx glc;
- void *private_data;
- int private_data_size;
- int textures_lost;
-};
-
-static inline uint8_t *copy_opposite_image(GLCanvas *canvas, void *data, int stride, int height)
-{
- uint8_t *ret_data = (uint8_t *)data;
- uint8_t *dest;
- uint8_t *src;
- int i;
-
- if (!canvas->private_data) {
- canvas->private_data = spice_malloc_n(height, stride);
- if (!canvas->private_data) {
- return ret_data;
- }
- canvas->private_data_size = stride * height;
- }
-
- if (canvas->private_data_size < (stride * height)) {
- free(canvas->private_data);
- canvas->private_data = spice_malloc_n(height, stride);
- if (!canvas->private_data) {
- return ret_data;
- }
- canvas->private_data_size = stride * height;
- }
-
- dest = (uint8_t *)canvas->private_data;
- src = (uint8_t *)data + (height - 1) * stride;
-
- for (i = 0; i < height; ++i) {
- memcpy(dest, src, stride);
- dest += stride;
- src -= stride;
- }
- return (uint8_t *)canvas->private_data;
-}
-
-static pixman_image_t *canvas_surf_to_trans_surf(GLCImage *image,
- uint32_t trans_color)
-{
- int width = image->width;
- int height = image->height;
- uint8_t *src_line;
- uint8_t *end_src_line;
- int src_stride;
- uint8_t *dest_line;
- int dest_stride;
- pixman_image_t *ret;
- int i;
-
- ret = pixman_image_create_bits(PIXMAN_a8r8g8b8, width, height, NULL, 0);
- if (ret == NULL) {
- CANVAS_ERROR("create surface failed");
- }
-
- src_line = image->pixels;
- src_stride = image->stride;
- end_src_line = src_line + src_stride * height;
-
- dest_line = (uint8_t *)pixman_image_get_data(ret);
- dest_stride = pixman_image_get_stride(ret);
-
- for (; src_line < end_src_line; src_line += src_stride, dest_line += dest_stride) {
- for (i = 0; i < width; i++) {
- if ((((uint32_t*)src_line)[i] & 0x00ffffff) == trans_color) {
- ((uint32_t*)dest_line)[i] = 0;
- } else {
- ((uint32_t*)dest_line)[i] = (((uint32_t*)src_line)[i]) | 0xff000000;
- }
- }
- }
-
- return ret;
-}
-
-static GLCPath get_path(GLCanvas *canvas, SpicePath *s)
-{
- GLCPath path = glc_path_create(canvas->glc);
- int i;
-
- for (i = 0; i < s->num_segments; i++) {
- SpicePathSeg* seg = s->segments[i];
- SpicePointFix* point = seg->points;
- SpicePointFix* end_point = point + seg->count;
-
- if (seg->flags & SPICE_PATH_BEGIN) {
- glc_path_move_to(path, fix_to_double(point->x), fix_to_double(point->y));
- point++;
- }
-
- if (seg->flags & SPICE_PATH_BEZIER) {
- ASSERT((point - end_point) % 3 == 0);
- for (; point + 2 < end_point; point += 3) {
- glc_path_curve_to(path,
- 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++) {
- glc_path_line_to(path, fix_to_double(point->x), fix_to_double(point->y));
- }
- }
- if (seg->flags & SPICE_PATH_END) {
- if (seg->flags & SPICE_PATH_CLOSE) {
- glc_path_close(path);
- }
- }
- }
-
- return path;
-}
-
-#define SET_GLC_RECT(dest, src) { \
- (dest)->x = (src)->left; \
- (dest)->y = (src)->top; \
- (dest)->width = (src)->right - (src)->left; \
- (dest)->height = (src)->bottom - (src)->top; \
-}
-
-#define SET_GLC_BOX(dest, src) { \
- (dest)->x = (src)->x1; \
- (dest)->y = (src)->y1; \
- (dest)->width = (src)->x2 - (src)->x1; \
- (dest)->height = (src)->y2 - (src)->y1; \
-}
-
-static void set_clip(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip)
-{
- GLCRect rect;
- glc_clip_reset(canvas->glc);
-
- switch (clip->type) {
- case SPICE_CLIP_TYPE_NONE:
- break;
- case SPICE_CLIP_TYPE_RECTS: {
- uint32_t n = clip->rects->num_rects;
- SpiceRect *now = clip->rects->rects;
- SpiceRect *end = now + n;
-
- if (n == 0) {
- rect.x = rect.y = 0;
- rect.width = rect.height = 0;
- glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
- break;
- } else {
- SET_GLC_RECT(&rect, now);
- glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
- }
-
- for (now++; now < end; now++) {
- SET_GLC_RECT(&rect, now);
- glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_OR);
- }
- break;
- }
- default:
- CANVAS_ERROR("invalid clip type");
- }
-}
-
-static void set_mask(GLCanvas *canvas, SpiceQMask *mask, int x, int y)
-{
- pixman_image_t *image;
-
- if (!(image = canvas_get_mask(&canvas->base, mask, NULL))) {
- glc_clear_mask(canvas->glc, GLC_MASK_A);
- return;
- }
-
-
- glc_set_mask(canvas->glc, x - mask->pos.x, y - mask->pos.y,
- pixman_image_get_width(image),
- pixman_image_get_height(image),
- pixman_image_get_stride(image),
- (uint8_t *)pixman_image_get_data(image), GLC_MASK_A);
-}
-
-static inline void surface_to_image(GLCanvas *canvas, pixman_image_t *surface, GLCImage *image,
- int ignore_stride)
-{
- int depth = pixman_image_get_depth(surface);
-
- ASSERT(depth == 32 || depth == 24);
- image->format = (depth == 24) ? GLC_IMAGE_RGB32 : GLC_IMAGE_ARGB32;
- image->width = pixman_image_get_width(surface);
- image->height = pixman_image_get_height(surface);
- image->stride = pixman_image_get_stride(surface);
- image->pixels = (uint8_t *)pixman_image_get_data(surface);
- image->pallet = NULL;
- if (ignore_stride) {
- return;
- }
- if (image->stride < 0) {
- image->stride = -image->stride;
- image->pixels = image->pixels - (image->height - 1) * image->stride;
- } else {
- image->pixels = copy_opposite_image(canvas, image->pixels, image->stride, image->height);
- }
-}
-
-static void set_brush(GLCanvas *canvas, SpiceBrush *brush)
-{
- switch (brush->type) {
- case SPICE_BRUSH_TYPE_SOLID: {
- uint32_t 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;
- glc_set_rgb(canvas->glc, r, g, b);
- break;
- }
- case SPICE_BRUSH_TYPE_PATTERN: {
- GLCImage image;
- GLCPattern pattern;
- pixman_image_t *surface;
-
- surface = canvas_get_image(&canvas->base, brush->u.pattern.pat, FALSE);
- surface_to_image(canvas, surface, &image, 0);
-
- pattern = glc_pattern_create(canvas->glc, -brush->u.pattern.pos.x,
- -brush->u.pattern.pos.y, &image);
-
- glc_set_pattern(canvas->glc, pattern);
- glc_pattern_destroy(pattern);
- pixman_image_unref (surface);
- }
- case SPICE_BRUSH_TYPE_NONE:
- return;
- default:
- CANVAS_ERROR("invalid brush type");
- }
-}
-
-static void set_op(GLCanvas *canvas, uint16_t rop_decriptor)
-{
- GLCOp op;
-
- switch (rop_decriptor) {
- case SPICE_ROPD_OP_PUT:
- op = GLC_OP_COPY;
- break;
- case SPICE_ROPD_OP_XOR:
- op = GLC_OP_XOR;
- break;
- case SPICE_ROPD_OP_BLACKNESS:
- op = GLC_OP_CLEAR;
- break;
- case SPICE_ROPD_OP_WHITENESS:
- op = GLC_OP_SET;
- break;
- case SPICE_ROPD_OP_PUT | SPICE_ROPD_INVERS_BRUSH:
- case SPICE_ROPD_OP_PUT | SPICE_ROPD_INVERS_SRC:
- op = GLC_OP_COPY_INVERTED;
- break;
- case SPICE_ROPD_OP_INVERS:
- op = GLC_OP_INVERT;
- break;
- case SPICE_ROPD_OP_AND:
- op = GLC_OP_AND;
- break;
- case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_RES:
- op = GLC_OP_NAND;
- break;
- case SPICE_ROPD_OP_OR:
- op = GLC_OP_OR;
- break;
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_RES:
- op = GLC_OP_NOR;
- break;
- case SPICE_ROPD_OP_XOR | SPICE_ROPD_INVERS_RES:
- op = GLC_OP_EQUIV;
- break;
- case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_DEST:
- op = GLC_OP_AND_REVERSE;
- break;
- case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_BRUSH:
- case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_SRC:
- op = GLC_OP_AND_INVERTED;
- break;
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_DEST:
- op = GLC_OP_OR_REVERSE;
- break;
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_BRUSH:
- case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_SRC:
- op = GLC_OP_OR_INVERTED;
- break;
- default:
- WARN("GLC_OP_NOOP");
- op = GLC_OP_NOOP;
- }
- glc_set_op(canvas->glc, op);
-}
-
-static void gl_canvas_draw_fill(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- GLCRect rect;
- set_clip(canvas, bbox, clip);
- set_mask(canvas, &fill->mask, bbox->left, bbox->top);
- set_brush(canvas, &fill->brush);
- set_op(canvas, fill->rop_descriptor);
- SET_GLC_RECT(&rect, bbox);
-
- glc_fill_rect(canvas->glc, &rect);
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_draw_copy(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- pixman_image_t *surface;
- GLCRecti src;
- GLCRecti dest;
- GLCImage image;
-
- set_clip(canvas, bbox, clip);
- set_mask(canvas, ©->mask, bbox->left, bbox->top);
- set_op(canvas, copy->rop_descriptor);
-
- //todo: optimize get_image (use ogl conversion + remove unnecessary copy of 32bpp)
- surface = canvas_get_image(&canvas->base, copy->src_bitmap, FALSE);
- surface_to_image(canvas, surface, &image, 0);
- SET_GLC_RECT(&dest, bbox);
- SET_GLC_RECT(&src, ©->src_area);
- glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
-
- pixman_image_unref(surface);
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_draw_opaque(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- pixman_image_t *surface;
- GLCRecti src;
- GLCRecti dest;
- GLCRect fill_rect;
- GLCImage image;
-
- set_clip(canvas, bbox, clip);
- set_mask(canvas, &opaque->mask, bbox->left, bbox->top);
-
- glc_set_op(canvas->glc, (opaque->rop_descriptor & SPICE_ROPD_INVERS_SRC) ? GLC_OP_COPY_INVERTED :
- GLC_OP_COPY);
- surface = canvas_get_image(&canvas->base, opaque->src_bitmap, FALSE);
- surface_to_image(canvas, surface, &image, 0);
- SET_GLC_RECT(&dest, bbox);
- SET_GLC_RECT(&src, &opaque->src_area);
- glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
- pixman_image_unref(surface);
-
- set_brush(canvas, &opaque->brush);
- set_op(canvas, opaque->rop_descriptor & ~SPICE_ROPD_INVERS_SRC);
- SET_GLC_RECT(&fill_rect, bbox);
- glc_fill_rect(canvas->glc, &fill_rect);
-
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_draw_alpha_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlend *alpha_blend)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- pixman_image_t *surface;
- GLCRecti src;
- GLCRecti dest;
- GLCImage image;
-
- set_clip(canvas, bbox, clip);
- glc_clear_mask(canvas->glc, GLC_MASK_A);
- glc_set_op(canvas->glc, GLC_OP_COPY);
-
- surface = canvas_get_image(&canvas->base, alpha_blend->src_bitmap, FALSE);
- surface_to_image(canvas, surface, &image, 0);
- SET_GLC_RECT(&dest, bbox);
- SET_GLC_RECT(&src, &alpha_blend->src_area);
- glc_draw_image(canvas->glc, &dest, &src, &image, 0, (double)alpha_blend->alpha / 0xff);
-
- pixman_image_unref(surface);
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_draw_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- pixman_image_t *surface;
- GLCRecti src;
- GLCRecti dest;
- GLCImage image;
-
- set_clip(canvas, bbox, clip);
- set_mask(canvas, &blend->mask, bbox->left, bbox->top);
- set_op(canvas, blend->rop_descriptor);
-
- surface = canvas_get_image(&canvas->base, blend->src_bitmap, FALSE);
- SET_GLC_RECT(&dest, bbox);
- SET_GLC_RECT(&src, &blend->src_area);
- surface_to_image(canvas, surface, &image, 0);
- glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
-
- pixman_image_unref(surface);
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_draw_transparent(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent *transparent)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- pixman_image_t *surface;
- pixman_image_t *trans_surf;
- GLCImage image;
- GLCRecti src;
- GLCRecti dest;
-
- set_clip(canvas, bbox, clip);
- glc_clear_mask(canvas->glc, GLC_MASK_A);
- glc_set_op(canvas->glc, GLC_OP_COPY);
-
- surface = canvas_get_image(&canvas->base, transparent->src_bitmap, FALSE);
- surface_to_image(canvas, surface, &image, 0);
-
- trans_surf = canvas_surf_to_trans_surf(&image, transparent->true_color);
- pixman_image_unref(surface);
-
- surface_to_image(canvas, trans_surf, &image, 1);
- SET_GLC_RECT(&dest, bbox);
- SET_GLC_RECT(&src, &transparent->src_area);
- glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
-
- pixman_image_unref(trans_surf);
- glc_flush(canvas->glc);
-}
-
-static inline void fill_common(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceQMask * mask, GLCOp op)
-{
- GLCRect rect;
-
- set_clip(canvas, bbox, clip);
- set_mask(canvas, mask, bbox->left, bbox->top);
- glc_set_op(canvas->glc, op);
- SET_GLC_RECT(&rect, bbox);
- glc_fill_rect(canvas->glc, &rect);
-}
-
-static void gl_canvas_draw_whiteness(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- fill_common(canvas, bbox, clip, &whiteness->mask, GLC_OP_SET);
-}
-
-static void gl_canvas_draw_blackness(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- fill_common(canvas, bbox, clip, &blackness->mask, GLC_OP_CLEAR);
-}
-
-static void gl_canvas_draw_invers(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- fill_common(canvas, bbox, clip, &invers->mask, GLC_OP_INVERT);
-}
-
-static void gl_canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- pixman_image_t *d;
- pixman_image_t *s;
- GLCImage image;
- SpicePoint src_pos;
- uint8_t *data_opp;
- int src_stride;
-
- set_clip(canvas, bbox, clip);
- set_mask(canvas, &rop3->mask, bbox->left, bbox->top);
-
- glc_set_op(canvas->glc, GLC_OP_COPY);
-
- image.format = GLC_IMAGE_RGB32;
- image.width = bbox->right - bbox->left;
- image.height = bbox->bottom - bbox->top;
-
- image.pallet = NULL;
-
- d = pixman_image_create_bits(PIXMAN_x8r8g8b8, image.width, image.height, NULL, 0);
- if (d == NULL) {
- CANVAS_ERROR("create surface failed");
- }
- image.pixels = (uint8_t *)pixman_image_get_data(d);
- image.stride = pixman_image_get_stride(d);
-
- glc_read_pixels(canvas->glc, bbox->left, bbox->top, &image);
- data_opp = copy_opposite_image(canvas, image.pixels,
- image.stride,
- pixman_image_get_height(d));
- memcpy(image.pixels, data_opp,
- image.stride * pixman_image_get_height(d));
-
- s = canvas_get_image(&canvas->base, rop3->src_bitmap, FALSE);
- src_stride = pixman_image_get_stride(s);
- if (src_stride > 0) {
- data_opp = copy_opposite_image(canvas, (uint8_t *)pixman_image_get_data(s),
- src_stride, pixman_image_get_height(s));
- memcpy((uint8_t *)pixman_image_get_data(s), data_opp,
- src_stride * pixman_image_get_height(s));
- }
-
- if (!rect_is_same_size(bbox, &rop3->src_area)) {
- pixman_image_t *scaled_s = canvas_scale_surface(s, &rop3->src_area, image.width,
- image.height, rop3->scale_mode);
- pixman_image_unref(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 (pixman_image_get_width(s) - src_pos.x < image.width ||
- pixman_image_get_height(s) - src_pos.y < image.height) {
- CANVAS_ERROR("bad src bitmap size");
- }
-
- if (rop3->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
- pixman_image_t *p = canvas_get_image(&canvas->base, rop3->brush.u.pattern.pat, FALSE);
- SpicePoint pat_pos;
-
- pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % pixman_image_get_width(p);
-
- pat_pos.y = (bbox->top - rop3->brush.u.pattern.pos.y) % pixman_image_get_height(p);
-
- //for now (bottom-top)
- if (pat_pos.y < 0) {
- pat_pos.y = pixman_image_get_height(p) + pat_pos.y;
- }
- pat_pos.y = (image.height + pat_pos.y) % pixman_image_get_height(p);
- pat_pos.y = pixman_image_get_height(p) - pat_pos.y;
-
- do_rop3_with_pattern(rop3->rop3, d, s, &src_pos, p, &pat_pos);
- pixman_image_unref(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);
- }
-
- pixman_image_unref(s);
-
- GLCRecti dest;
- GLCRecti src;
- dest.x = bbox->left;
- dest.y = bbox->top;
-
- image.pixels = copy_opposite_image(canvas, image.pixels, pixman_image_get_stride(d),
- pixman_image_get_height(d));
-
- src.x = src.y = 0;
- dest.width = src.width = image.width;
- dest.height = src.height = image.height;
- glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
- pixman_image_unref(d);
-}
-
-static void gl_canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- GLCPath path;
-
- set_clip(canvas, bbox, clip);
- glc_clear_mask(canvas->glc, GLC_MASK_A);
- set_op(canvas, stroke->fore_mode);
- set_brush(canvas, &stroke->brush);
-
- if (stroke->attr.flags & SPICE_LINE_FLAGS_STYLED) {
- WARN("SPICE_LINE_FLAGS_STYLED");
- }
- glc_set_line_width(canvas->glc, 1.0);
-
- path = get_path(canvas, stroke->path);
- glc_stroke_path(canvas->glc, path);
- glc_path_destroy(path);
-}
-
-static void gl_canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- GLCRect rect;
- SpiceString *str;
-
- set_clip(canvas, bbox, clip);
- glc_clear_mask(canvas->glc, GLC_MASK_A);
-
- if (!rect_is_empty(&text->back_area)) {
- set_brush(canvas, &text->back_brush);
- set_op(canvas, text->back_mode);
- SET_GLC_RECT(&rect, bbox);
- glc_fill_rect(canvas->glc, &rect);
- }
-
- str = (SpiceString *)SPICE_GET_ADDRESS(text->str);
- set_brush(canvas, &text->fore_brush);
- set_op(canvas, text->fore_mode);
- if (str->flags & SPICE_STRING_FLAGS_RASTER_A1) {
- SpicePoint pos;
- pixman_image_t *mask = canvas_get_str_mask(&canvas->base, str, 1, &pos);
- _glc_fill_mask(canvas->glc, pos.x, pos.y,
- pixman_image_get_width(mask),
- pixman_image_get_height(mask),
- pixman_image_get_stride(mask),
- (uint8_t *)pixman_image_get_data(mask));
- pixman_image_unref(mask);
- } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A4) {
- SpicePoint pos;
- pixman_image_t *mask = canvas_get_str_mask(&canvas->base, str, 4, &pos);
- glc_fill_alpha(canvas->glc, pos.x, pos.y,
- pixman_image_get_width(mask),
- pixman_image_get_height(mask),
- pixman_image_get_stride(mask),
- (uint8_t *)pixman_image_get_data(mask));
-
- pixman_image_unref(mask);
- } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
- WARN("untested path A8 glyphs, doing nothing");
- if (0) {
- SpicePoint pos;
- pixman_image_t *mask = canvas_get_str_mask(&canvas->base, str, 8, &pos);
- glc_fill_alpha(canvas->glc, pos.x, pos.y,
- pixman_image_get_width(mask),
- pixman_image_get_height(mask),
- pixman_image_get_stride(mask),
- (uint8_t *)pixman_image_get_data(mask));
- pixman_image_unref(mask);
- }
- } else {
- WARN("untested path vector glyphs, doing nothing");
- if (0) {
- //draw_vector_str(canvas, str, &text->fore_brush, text->fore_mode);
- }
- }
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_clear(SpiceCanvas *spice_canvas)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- glc_clear(canvas->glc);
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_copy_bits(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- set_clip(canvas, bbox, clip);
- glc_clear_mask(canvas->glc, GLC_MASK_A);
- glc_set_op(canvas->glc, GLC_OP_COPY);
- glc_copy_pixels(canvas->glc, bbox->left, bbox->top, src_pos->x, src_pos->y,
- bbox->right - bbox->left, bbox->bottom - bbox->top);
-}
-
-static void gl_canvas_read_bits(SpiceCanvas *spice_canvas, uint8_t *dest, int dest_stride, const SpiceRect *area)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- GLCImage image;
-
- ASSERT(dest_stride > 0);
- image.format = GLC_IMAGE_RGB32;
- image.height = area->bottom - area->top;
- image.width = area->right - area->left;
- image.pixels = dest;
- image.stride = dest_stride;
- glc_read_pixels(canvas->glc, area->left, area->top, &image);
-}
-
-static void gl_canvas_group_start(SpiceCanvas *spice_canvas, QRegion *region)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- GLCRect *glc_rects;
- GLCRect *now, *end;
- int num_rect;
- pixman_box32_t *rects;
-
- canvas_base_group_start(spice_canvas, region);
-
- rects = pixman_region32_rectangles(region, &num_rect);
-
- glc_rects = spice_new(GLCRect, num_rect);
- now = glc_rects;
- end = glc_rects + num_rect;
-
- for (; now < end; now++, rects++) {
- SET_GLC_BOX(now, rects);
- }
- glc_mask_rects(canvas->glc, num_rect, glc_rects, GLC_MASK_B);
-
- free(glc_rects);
-}
-
-static void gl_canvas_put_image(SpiceCanvas *spice_canvas, const SpiceRect *dest, const uint8_t *src_data,
- uint32_t src_width, uint32_t src_height, int src_stride,
- const QRegion *clip)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
- GLCRecti src;
- GLCRecti gldest;
- GLCImage image;
- uint32_t i;
-
- ASSERT(src_stride <= 0)
- glc_clip_reset(canvas->glc);
-
- if (clip) {
- int num_rects;
- pixman_box32_t *rects = pixman_region32_rectangles((pixman_region32_t *)clip,
- &num_rects);
- GLCRect rect;
- if (num_rects == 0) {
- rect.x = rect.y = rect.width = rect.height = 0;
- glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
- } else {
- SET_GLC_BOX(&rect, rects);
- glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
- for (i = 1; i < num_rects; i++) {
- SET_GLC_BOX(&rect, rects + i);
- glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_OR);
- }
- }
- }
-
- SET_GLC_RECT(&gldest, dest);
- src.x = src.y = 0;
- src.width = src_width;
- src.height = src_height;
-
- image.format = GLC_IMAGE_RGB32;
- image.width = src_width;
- image.height = src_height;
- src_stride = -src_stride;
- image.stride = src_stride;
- image.pixels = (uint8_t *)src_data - (src_height - 1) * src_stride;
- image.pallet = NULL;
- glc_draw_image(canvas->glc, &gldest, &src, &image, 0, 1);
-
- glc_flush(canvas->glc);
-}
-
-static void gl_canvas_group_end(SpiceCanvas *spice_canvas)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
-
- canvas_base_group_end(spice_canvas);
- glc_clear_mask(canvas->glc, GLC_MASK_B);
-}
-
-static int need_init = 1;
-static SpiceCanvasOps gl_canvas_ops;
-
-SpiceCanvas *gl_canvas_create(int width, int height, uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- )
-{
- GLCanvas *canvas;
- int init_ok;
-
- if (need_init) {
- return NULL;
- }
- canvas = spice_new0(GLCanvas, 1);
-
- if (!(canvas->glc = glc_create(width, height))) {
- goto error_1;
- }
- canvas->private_data = NULL;
- init_ok = canvas_base_init(&canvas->base, &gl_canvas_ops,
- width, height, format
-#ifdef SW_CANVAS_CACHE
- , bits_cache
- , palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , bits_cache
-#endif
- , surfaces
- , glz_decoder
- , jpeg_decoder
- , zlib_decoder
- );
- if (!init_ok) {
- goto error_2;
- }
-
- return (SpiceCanvas *)canvas;
-
-error_2:
- glc_destroy(canvas->glc, 0);
-error_1:
- free(canvas);
-
- return NULL;
-}
-
-void gl_canvas_set_textures_lost(SpiceCanvas *spice_canvas,
- int textures_lost)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
-
- canvas->textures_lost = textures_lost;
-}
-
-static void gl_canvas_destroy(SpiceCanvas *spice_canvas)
-{
- GLCanvas *canvas = (GLCanvas *)spice_canvas;
-
- if (!canvas) {
- return;
- }
- canvas_base_destroy(&canvas->base);
- glc_destroy(canvas->glc, canvas->textures_lost);
- free(canvas->private_data);
- free(canvas);
-}
-
-void gl_canvas_init(void) //unsafe global function
-{
- if (!need_init) {
- return;
- }
- need_init = 0;
-
- canvas_base_init_ops(&gl_canvas_ops);
- gl_canvas_ops.draw_fill = gl_canvas_draw_fill;
- gl_canvas_ops.draw_copy = gl_canvas_draw_copy;
- gl_canvas_ops.draw_opaque = gl_canvas_draw_opaque;
- gl_canvas_ops.copy_bits = gl_canvas_copy_bits;
- gl_canvas_ops.draw_text = gl_canvas_draw_text;
- gl_canvas_ops.draw_stroke = gl_canvas_draw_stroke;
- gl_canvas_ops.draw_rop3 = gl_canvas_draw_rop3;
- gl_canvas_ops.draw_blend = gl_canvas_draw_blend;
- gl_canvas_ops.draw_blackness = gl_canvas_draw_blackness;
- gl_canvas_ops.draw_whiteness = gl_canvas_draw_whiteness;
- gl_canvas_ops.draw_invers = gl_canvas_draw_invers;
- gl_canvas_ops.draw_transparent = gl_canvas_draw_transparent;
- gl_canvas_ops.draw_alpha_blend = gl_canvas_draw_alpha_blend;
- gl_canvas_ops.put_image = gl_canvas_put_image;
- gl_canvas_ops.clear = gl_canvas_clear;
- gl_canvas_ops.read_bits = gl_canvas_read_bits;
- gl_canvas_ops.group_start = gl_canvas_group_start;
- gl_canvas_ops.group_end = gl_canvas_group_end;
- gl_canvas_ops.destroy = gl_canvas_destroy;
-
- rop3_init();
-}
diff --git a/common/gl_canvas.h b/common/gl_canvas.h
deleted file mode 100644
index 400bedb..0000000
--- a/common/gl_canvas.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "glc.h"
-#include "canvas_base.h"
-#include "region.h"
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This header shouldn't be included directly"
-#endif
-
-#ifndef _H__GL_CANVAS
-#define _H__GL_CANVAS
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-SpiceCanvas *gl_canvas_create(int width, int height, uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- );
-void gl_canvas_set_textures_lost(SpiceCanvas *canvas, int textures_lost);
-void gl_canvas_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/gl_utils.h b/common/gl_utils.h
deleted file mode 100644
index c30be16..0000000
--- a/common/gl_utils.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
-
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#ifndef GL_UTILS_H
-#define GL_UTILS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef RED_DEBUG
-#define GLC_ERROR_TEST_FLUSH { \
- GLenum gl_err; glFlush(); \
- if ((gl_err = glGetError()) != GL_NO_ERROR) { \
- printf("%s[%d]: opengl error: %s\n", __FUNCTION__, __LINE__, \
- gluErrorString(gl_err)); \
- abort(); \
- } \
-}
-
-#define GLC_ERROR_TEST_FINISH { \
- GLenum gl_err; glFinish(); \
- if ((gl_err = glGetError()) != GL_NO_ERROR) { \
- printf("%s[%d]: opengl error: %s\n", __FUNCTION__, __LINE__, \
- gluErrorString(gl_err)); \
- abort(); \
- } \
-}
-#else
-#define GLC_ERROR_TEST_FLUSH ;
-
-#define GLC_ERROR_TEST_FINISH ;
-#endif
-
-#include "bitops.h"
-
-#define find_msb spice_bit_find_msb
-#define gl_get_to_power_two spice_bit_next_pow2
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/glc.c b/common/glc.c
deleted file mode 100644
index 1414bcf..0000000
--- a/common/glc.c
+++ /dev/null
@@ -1,1513 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
-
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-#include <spice/macros.h>
-
-#include <GL/gl.h>
-#include <GL/glu.h>
-#include <GL/glext.h>
-
-#ifdef WIN32
-#include "glext.h"
-#include "wglext.h"
-#endif
-
-#include "mem.h"
-#include "glc.h"
-#include "gl_utils.h"
-#include "spice_common.h"
-
-#define TESS_VERTEX_ALLOC_BUNCH 20
-
-typedef struct InternaCtx InternaCtx;
-typedef struct InternalPat {
- InternaCtx *owner;
- int refs;
- GLuint texture;
- int x_orign;
- int y_orign;
- int width;
- int height;
-} InternalPat;
-
-typedef struct Pathpath {
- int start_point;
- int num_segments;
-} Path;
-
-enum {
- GLC_PATH_SEG_LINES,
- GLC_PATH_SEG_BEIZER,
-};
-
-//todo: flatten cache
-typedef struct PathSegment {
- int type;
- int count;
-} PathSegment;
-
-typedef struct PathPoint {
- double x;
- double y;
- double z;
-} PathPoint;
-
-typedef GLdouble Vertex[3];
-
-typedef struct InternalPath {
- InternaCtx *owner;
-
- Path *paths;
- int paths_size;
- int paths_pos;
-
- PathSegment *segments;
- int segments_size;
- int segments_pos;
-
- PathPoint *points;
- int points_size;
- int points_pos;
-
- Path *current_path;
- PathSegment *current_segment;
-} InternalPath;
-
-typedef struct TassVertex TassVertex;
-struct TassVertex {
- PathPoint point;
- TassVertex *list_link;
- TassVertex *next;
-};
-
-typedef struct TassVertexBuf TassVertexBuf;
-struct TassVertexBuf {
- TassVertexBuf *next;
- TassVertex vertexs[0];
-};
-
-#define USE_LINE_ANTIALIAS 0
-
-typedef struct LineDash {
- double *dashes;
- int num_dashes;
- double offset;
- int cur_dash;
- double dash_pos;
-} LineDash;
-
-enum {
- GLC_STROKE_NONACTIVE,
- GLC_STROKE_FIRST,
- GLC_STROKE_ACTIVE,
-};
-
-typedef struct PathStroke {
- double x;
- double y;
- int state;
-} PathStroke;
-
-struct InternaCtx {
- int draw_mode;
- int stencil_refs;
- int stencil_mask;
- int width;
- int height;
- GLfloat line_width;
- LineDash line_dash;
- PathStroke path_stroke;
- InternalPat *pat;
- int max_texture_size;
- GLUtesselator* tesselator;
- TassVertex *free_tess_vertex;
- TassVertex *used_tess_vertex;
- TassVertexBuf *vertex_bufs;
- int private_tex_width;
- int private_tex_height;
- GLuint private_tex;
-#ifdef WIN32
- PFNGLBLENDEQUATIONPROC glBlendEquation;
-#endif
-};
-
-#define Y(y) -(y)
-#define VERTEX2(x, y) glVertex2d(x, Y(y))
-
-static void fill_rect(InternaCtx *ctx, void *rect);
-static void fill_path(InternaCtx *ctx, void *path);
-static void fill_mask(InternaCtx *ctx, int x_dest, int y_dest, int width, int height, int stride,
- const uint8_t *bitmap);
-static void set_pat(InternaCtx *ctx, InternalPat *pat);
-
-static inline void set_raster_pos(InternaCtx *ctx, int x, int y)
-{
- if (x >= 0 && y >= 0 && x < ctx->width && y < ctx->height) {
- glRasterPos2i(x, Y(y));
- return;
- }
- glRasterPos2i(0, 0);
- glBitmap(0, 0, 0, 0, (GLfloat)x, (GLfloat)Y(y), NULL);
-}
-
-static TassVertex *alloc_tess_vertex(InternaCtx *ctx)
-{
- TassVertex *vertex;
-
- if (!ctx->free_tess_vertex) {
- TassVertexBuf *buf;
- int i;
-
- buf = (TassVertexBuf *)spice_malloc(sizeof(TassVertexBuf) +
- sizeof(TassVertex) * TESS_VERTEX_ALLOC_BUNCH);
- buf->next = ctx->vertex_bufs;
- ctx->vertex_bufs = buf;
- for (i = 0; i < TESS_VERTEX_ALLOC_BUNCH; i++) {
- buf->vertexs[i].point.z = 0;
- buf->vertexs[i].next = ctx->free_tess_vertex;
- ctx->free_tess_vertex = &buf->vertexs[i];
- }
- }
-
- vertex = ctx->free_tess_vertex;
- ctx->free_tess_vertex = vertex->next;
- vertex->next = ctx->used_tess_vertex;
- ctx->used_tess_vertex = vertex;
- return vertex;
-}
-
-static void reset_tass_vertex(InternaCtx *ctx)
-{
- TassVertex *vertex;
- while ((vertex = ctx->used_tess_vertex)) {
- ctx->used_tess_vertex = vertex->next;
- vertex->next = ctx->free_tess_vertex;
- ctx->free_tess_vertex = vertex;
- }
-}
-
-static void free_tass_vertex_bufs(InternaCtx *ctx)
-{
- TassVertexBuf *buf;
-
- ctx->used_tess_vertex = NULL;
- ctx->free_tess_vertex = NULL;
- while ((buf = ctx->vertex_bufs)) {
- ctx->vertex_bufs = buf->next;
- free(buf);
- }
-}
-
-//naive bezier flattener
-static TassVertex *bezier_flattener(InternaCtx *ctx, PathPoint *points)
-{
- double ax, bx, cx;
- double ay, by, cy;
- const int num_points = 30;
- double dt;
- int i;
-
- TassVertex *vertex_list = NULL;
- TassVertex *curr_vertex;
-
- for (i = 0; i < num_points - 2; i++) {
- TassVertex *vertex;
-
- vertex = alloc_tess_vertex(ctx);
- vertex->list_link = vertex_list;
- vertex_list = vertex;
- }
-
- curr_vertex = vertex_list;
-
- cx = 3.0 * (points[1].x - points[0].x);
- bx = 3.0 * (points[2].x - points[1].x) - cx;
- ax = points[3].x - points[0].x - cx - bx;
-
- cy = 3.0 * (points[1].y - points[0].y);
- by = 3.0 * (points[2].y - points[1].y) - cy;
- ay = points[3].y - points[0].y - cy - by;
-
- dt = 1.0 / (num_points - 1);
-
- for (i = 1; i < num_points - 1; i++, curr_vertex = curr_vertex->list_link) {
- double tSquared, tCubed;
- double t;
- t = i * dt;
-
- tSquared = t * t;
- tCubed = tSquared * t;
-
- curr_vertex->point.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + points[0].x;
- curr_vertex->point.y = (ay * tCubed) + (by * tSquared) + (cy * t) + points[0].y;
- }
-
- return vertex_list;
-}
-
-#define MORE_X(path, Type, name) { \
- Type *name; \
- \
- name = spice_new0(Type, path->name##_size * 2); \
- memcpy(name, path->name, sizeof(*name) * path->name##_size); \
- free(path->name); \
- path->name = name; \
- path->name##_size *= 2; \
-}
-
-static void more_points(InternalPath *path)
-{
- MORE_X(path, PathPoint, points);
-}
-
-static void more_segments(InternalPath *path)
-{
- MORE_X(path, PathSegment, segments);
-}
-
-static void more_paths(InternalPath *path)
-{
- MORE_X(path, Path, paths);
-}
-
-static inline void put_point(InternalPath *path, double x, double y)
-{
- path->points[path->points_pos].x = x;
- path->points[path->points_pos].y = Y(y + 0.5);
- path->points[path->points_pos++].z = 0;
-}
-
-void glc_path_move_to(GLCPath path, double x, double y)
-{
- InternalPath *internal = (InternalPath *)path;
-
- ASSERT(internal);
-
- if (internal->current_segment) {
- internal->current_segment = NULL;
- internal->current_path = NULL;
- if (internal->points_pos == internal->points_size) {
- more_points(internal);
- }
- internal->points_pos++;
- }
- internal->points[internal->points_pos - 1].x = x;
- internal->points[internal->points_pos - 1].y = Y(y + 0.5);
- internal->points[internal->points_pos - 1].z = 0;
-}
-
-static void add_segment_common(InternalPath *internal, int type, int num_points)
-{
- if (internal->points_size - internal->points_pos < num_points) {
- more_points(internal);
- }
-
- if (internal->current_segment) {
- if (internal->current_segment->type == type) {
- internal->current_segment->count++;
- return;
- }
- if (internal->segments_pos == internal->segments_size) {
- more_segments(internal);
- }
- internal->current_segment = &internal->segments[internal->segments_pos++];
- internal->current_segment->type = type;
- internal->current_segment->count = 1;
- internal->current_path->num_segments++;
- return;
- }
-
- if (internal->paths_pos == internal->paths_size) {
- more_paths(internal);
- }
-
- if (internal->segments_pos == internal->segments_size) {
- more_segments(internal);
- }
-
- internal->current_path = &internal->paths[internal->paths_pos++];
- internal->current_path->start_point = internal->points_pos - 1;
- internal->current_path->num_segments = 1;
- internal->current_segment = &internal->segments[internal->segments_pos++];
- internal->current_segment->type = type;
- internal->current_segment->count = 1;
-}
-
-void glc_path_line_to(GLCPath path, double x, double y)
-{
- InternalPath *internal = (InternalPath *)path;
-
- ASSERT(internal);
-
- add_segment_common(internal, GLC_PATH_SEG_LINES, 1);
- put_point(internal, x, y);
-}
-
-void glc_path_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
- double p3_x, double p3_y)
-{
- InternalPath *internal = (InternalPath *)path;
-
- ASSERT(internal);
-
- add_segment_common(internal, GLC_PATH_SEG_BEIZER, 3);
- put_point(internal, p1_x, p1_y);
- put_point(internal, p2_x, p2_y);
- put_point(internal, p3_x, p3_y);
-}
-
-void glc_path_close(GLCPath path)
-{
- InternalPath *internal = (InternalPath *)path;
-
- ASSERT(internal);
- if (!internal->current_path) {
- return;
- }
- PathPoint *end_point = &internal->points[internal->current_path->start_point];
- glc_path_line_to(path, end_point->x, Y(end_point->y));
- glc_path_move_to(path, end_point->x, Y(end_point->y));
-}
-
-void glc_path_cleare(GLCPath path)
-{
- InternalPath *internal = (InternalPath *)path;
-
- ASSERT(internal);
- internal->paths_pos = internal->segments_pos = 0;
- internal->current_segment = NULL;
- internal->current_path = NULL;
-
- internal->points[0].x = 0;
- internal->points[0].y = 0;
- internal->points_pos = 1;
-}
-
-GLCPath glc_path_create(GLCCtx glc)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- InternalPath *path;
-
- ASSERT(ctx);
- path = spice_new0(InternalPath, 1);
- path->paths_size = 2;
- path->paths = spice_new(Path, path->paths_size);
-
- path->segments_size = 4;
- path->segments = spice_new(PathSegment, path->segments_size);
-
- path->points_size = 20;
- path->points = spice_new(PathPoint, path->points_size);
-
- path->owner = ctx;
- path->points_pos = 1;
- return path;
-}
-
-void glc_path_destroy(GLCPath path)
-{
- InternalPath *internal = (InternalPath *)path;
-
- if (!path) {
- return;
- }
-
- free(internal->points);
- free(internal->segments);
- free(internal->paths);
- free(internal);
-}
-
-static inline void unref_pat(InternalPat *pat)
-{
- if (!pat) {
- return;
- }
- ASSERT(pat->refs > 0);
- if (--pat->refs == 0) {
- glFinish();
- glDeleteTextures(1, &pat->texture);
- free(pat);
- }
- GLC_ERROR_TEST_FLUSH;
-}
-
-static inline InternalPat *ref_pat(InternalPat *pat)
-{
- pat->refs++;
- return pat;
-}
-
-static void scale(uint32_t *dest, uint32_t dest_width, uint32_t dest_height,
- uint32_t *src, uint32_t src_width, uint32_t src_height, int src_stride)
-{
- double x_scale = (double)src_width / dest_width;
- double y_scale = (double)src_height / dest_height;
- uint32_t i;
- uint32_t j;
- int prev_row = -1;
-
- for (i = 0; i < dest_height; i++) {
- int row = (int)(y_scale * i);
- if (row == prev_row) {
- memcpy(dest, dest - dest_width, dest_width * sizeof(uint32_t));
- dest += dest_width;
- continue;
- }
- for (j = 0; j < dest_width; j++) {
- int col = (int)(x_scale * j);
- *(dest++) = *(src + col);
- }
- prev_row = row;
- src = (uint32_t *)((uint8_t *)src + src_stride);
- }
-}
-
-static inline void init_pattern(InternalPat *pat, int x_orign, int y_orign, const GLCImage *image)
-{
- InternaCtx *ctx = pat->owner;
- uint32_t *tmp_pixmap = NULL;
- int width;
- int height;
- int width2;
- int height2;
-
- const int pix_bytes = 4;
-
- ASSERT(image->format == GLC_IMAGE_RGB32); //for now
-
- width = image->width;
- height = image->height;
- width2 = gl_get_to_power_two(width);
- height2 = gl_get_to_power_two(height);
-
- ASSERT(width > 0 && height > 0);
- ASSERT(width > 0 && width <= pat->owner->max_texture_size);
- ASSERT(height > 0 && height <= pat->owner->max_texture_size);
-
- if (width2 != width || height2 != height) {
- tmp_pixmap = (uint32_t *)spice_malloc(width2 * height2 * sizeof(uint32_t));
- scale(tmp_pixmap, width2, height2, (uint32_t *)image->pixels, width, height, image->stride);
- }
-
- glBindTexture(GL_TEXTURE_2D, pat->texture);
-
- //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
- if (tmp_pixmap) {
- glPixelStorei(GL_UNPACK_ROW_LENGTH, width2);
- glTexImage2D(GL_TEXTURE_2D, 0, 4, width2, height2, 0, GL_BGRA, GL_UNSIGNED_BYTE,
- tmp_pixmap);
- free(tmp_pixmap);
- } else {
- ASSERT(image->stride % pix_bytes == 0);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, image->stride / pix_bytes);
- glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE,
- image->pixels);
- }
-
- GLC_ERROR_TEST_FLUSH;
- pat->x_orign = x_orign % width;
- pat->y_orign = y_orign % height;
- pat->width = width;
- pat->height = height;
-
- if (ctx->pat == pat) {
- set_pat(pat->owner, pat);
- } else if (ctx->pat) {
- glBindTexture(GL_TEXTURE_2D, ctx->pat->texture);
- }
-}
-
-GLCPattern glc_pattern_create(GLCCtx glc, int x_orign, int y_orign, const GLCImage *image)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- InternalPat *pat;
-
- ASSERT(ctx && image);
-
- pat = spice_new0(InternalPat, 1);
- pat->refs = 1;
- pat->owner = ctx;
- glGenTextures(1, &pat->texture);
- init_pattern(pat, x_orign, y_orign, image);
- return pat;
-}
-
-void glc_pattern_set(GLCPattern pattern, int x_orign, int y_orign, const GLCImage *image)
-{
- InternalPat *pat = (InternalPat *)pattern;
- ASSERT(pat && pat->owner);
-
- glFinish();
- init_pattern(pat, x_orign, y_orign, image);
-}
-
-void glc_pattern_destroy(GLCPattern pat)
-{
- unref_pat((InternalPat *)pat);
- GLC_ERROR_TEST_FLUSH;
-}
-
-static void set_pat(InternaCtx *ctx, InternalPat *pat)
-{
- pat = ref_pat(pat);
- unref_pat(ctx->pat);
- ctx->pat = pat;
-
- glEnable(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D, pat->texture);
-
- GLfloat s_gen_params[] = { (GLfloat)1.0 / pat->width, 0, 0, 0 };
- GLfloat t_gen_params[] = { 0, (GLfloat)1.0 / (GLfloat)pat->height, 0, 0 };
- glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
- glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);
-
- glMatrixMode(GL_TEXTURE);
- glLoadIdentity();
- glTranslatef((float)pat->x_orign / pat->width, (float)Y(pat->y_orign) / pat->height, 0);
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_set_pattern(GLCCtx glc, GLCPattern pattern)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- InternalPat *pat = (InternalPat *)pattern;
-
- ASSERT(ctx && pat && pat->owner == ctx);
- set_pat(ctx, pat);
-}
-
-void glc_set_rgb(GLCCtx glc, double red, double green, double blue)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx);
-
- glDisable(GL_TEXTURE_2D);
- unref_pat(ctx->pat);
- ctx->pat = NULL;
- glColor4d(red, green, blue, 1);
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_set_op(GLCCtx glc, GLCOp op)
-{
- if (op == GL_COPY) {
- glDisable(GL_COLOR_LOGIC_OP);
- return;
- }
- glLogicOp(op);
- glEnable(GL_COLOR_LOGIC_OP);
-}
-
-void glc_set_line_width(GLCCtx glc, double width)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx);
- ctx->line_width = (GLfloat)width;
- if (ctx->line_width > 0) {
- glLineWidth(ctx->line_width);
- } else {
- ctx->line_width = 0;
- }
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_set_line_dash(GLCCtx glc, const double *dashes, int num_dashes, double offset)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx);
- if (dashes && num_dashes >= 0 && offset >= 0) {
- ctx->line_dash.dashes = spice_new(double, num_dashes);
- memcpy(ctx->line_dash.dashes, dashes, sizeof(double) * num_dashes);
- ctx->line_dash.num_dashes = num_dashes;
- ctx->line_dash.offset = offset;
- ctx->line_dash.cur_dash = offset ? -1 : 0;
- ctx->line_dash.dash_pos = 0;
- } else {
- free(ctx->line_dash.dashes);
- memset(&ctx->line_dash, 0, sizeof(ctx->line_dash));
- }
-}
-
-void glc_set_fill_mode(GLCCtx glc, GLCFillMode fill_mode)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx);
- int mode;
- switch (fill_mode) {
- case GLC_FILL_MODE_WINDING_ODD:
- mode = GLU_TESS_WINDING_ODD;
- break;
- case GLC_FILL_MODE_WINDING_NONZERO:
- mode = GLU_TESS_WINDING_NONZERO;
- break;
- default:
- //warn
- return;
- }
- gluTessProperty(ctx->tesselator, GLU_TESS_WINDING_RULE, mode);
-}
-
-static inline void add_stencil_client(InternaCtx *ctx)
-{
- if (!ctx->stencil_refs) {
- glEnable(GL_STENCIL_TEST);
- }
- ctx->stencil_refs++;
-}
-
-static inline void remove_stencil_client(InternaCtx *ctx)
-{
- ctx->stencil_refs--;
- if (!ctx->stencil_refs) {
- glDisable(GL_STENCIL_TEST);
- }
-}
-
-void glc_set_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
- int stride, const uint8_t *bitmap, GLCMaskID id)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
- ASSERT(ctx && bitmap);
- ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
-
- if (ctx->pat) {
- glDisable(GL_TEXTURE_2D);
- }
-
- glDisable(GL_BLEND);
-
- if (!(ctx->stencil_mask & mask)) {
- add_stencil_client(ctx);
- ctx->stencil_mask |= mask;
- }
-
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
- ctx->draw_mode = FALSE;
- glStencilMask(mask);
- glClear(GL_STENCIL_BUFFER_BIT);
-
- glStencilFunc(GL_ALWAYS, mask, mask);
- glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
- fill_mask(ctx, x_dest, y_dest, width, height, stride, bitmap);
-}
-
-void glc_mask_rects(GLCCtx glc, int num_rect, GLCRect *rects, GLCMaskID id)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
- GLCRect *end;
- ASSERT(ctx && rects);
- ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
-
- if (ctx->pat) {
- glDisable(GL_TEXTURE_2D);
- }
-
- glDisable(GL_BLEND);
-
- if (!(ctx->stencil_mask & mask)) {
- add_stencil_client(ctx);
- ctx->stencil_mask |= mask;
- }
-
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
- ctx->draw_mode = FALSE;
- glStencilMask(mask);
- glClear(GL_STENCIL_BUFFER_BIT);
-
- glStencilFunc(GL_ALWAYS, mask, mask);
- glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
- end = rects + num_rect;
- for (; rects < end; rects++) {
- fill_rect(ctx, rects);
- }
-}
-
-void glc_clear_mask(GLCCtx glc, GLCMaskID id)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
- ASSERT(ctx);
- ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
-
- if ((ctx->stencil_mask & mask)) {
- ctx->stencil_mask &= ~mask;
- remove_stencil_client(ctx);
- }
-}
-
-void glc_clip_reset(GLCCtx glc)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- if (!(ctx->stencil_mask & 0x03)) {
- return;
- }
- remove_stencil_client(ctx);
- ctx->stencil_mask &= ~0x03;
- glStencilMask(0x03);
- glClear(GL_STENCIL_BUFFER_BIT);
- GLC_ERROR_TEST_FLUSH;
-}
-
-static void clip_common(InternaCtx *ctx, GLCClipOp op, void (*fill_func)(InternaCtx *, void *),
- void *data)
-{
- int stencil_val;
-
- if (ctx->pat) {
- glDisable(GL_TEXTURE_2D);
- }
- glDisable(GL_BLEND);
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
- ctx->draw_mode = FALSE;
-
- if (op == GLC_CLIP_OP_SET) {
- glc_clip_reset(ctx);
- add_stencil_client(ctx);
- ctx->stencil_mask |= 0x01;
- } else if (!(ctx->stencil_mask & 0x03)) {
- GLCRect area;
- if (op == GLC_CLIP_OP_OR) {
- return;
- }
- area.x = area.y = 0;
- area.width = ctx->width;
- area.height = ctx->height;
- clip_common(ctx, GLC_CLIP_OP_SET, fill_rect, &area);
- }
- glStencilMask(0x03);
- switch (op) {
- case GLC_CLIP_OP_SET:
- case GLC_CLIP_OP_OR:
- stencil_val = ctx->stencil_mask & 0x03;
- glStencilFunc(GL_ALWAYS, stencil_val, stencil_val);
- glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
- fill_func(ctx, data);
- break;
- case GLC_CLIP_OP_AND: {
- int clear_mask;
- stencil_val = ctx->stencil_mask & 0x03;
- glStencilFunc(GL_EQUAL, stencil_val, stencil_val);
- if (stencil_val == 0x01) {
- glStencilOp(GL_ZERO, GL_INCR, GL_INCR);
- stencil_val = 0x02;
- clear_mask = 0x01;
- } else {
- glStencilOp(GL_ZERO, GL_DECR, GL_DECR);
- stencil_val = 0x01;
- clear_mask = 0x02;
- }
- fill_func(ctx, data);
-
- glStencilMask(clear_mask);
- glClear(GL_STENCIL_BUFFER_BIT);
- ctx->stencil_mask = (ctx->stencil_mask & ~clear_mask) | stencil_val;
- break;
- }
- case GLC_CLIP_OP_EXCLUDE:
- stencil_val = ctx->stencil_mask & 0x03;
- glStencilFunc(GL_EQUAL, stencil_val, stencil_val);
- glStencilOp(GL_KEEP, GL_ZERO, GL_ZERO);
- fill_func(ctx, data);
- break;
- }
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_clip_rect(GLCCtx glc, const GLCRect *rect, GLCClipOp op)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx && rect);
- clip_common(ctx, op, fill_rect, (void *)rect);
-}
-
-void glc_clip_path(GLCCtx glc, GLCPath path, GLCClipOp op)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx && path);
- clip_common(ctx, op, fill_path, path);
-}
-
-typedef struct FillMaskInfo {
- int x_dest;
- int y_dest;
- int width;
- int height;
- int stride;
- const uint8_t *bitmap;
-} FillMaskInfo;
-
-static void __fill_mask(InternaCtx *ctx, void *data)
-{
- FillMaskInfo *info = (FillMaskInfo *)data;
- fill_mask(ctx, info->x_dest, info->y_dest, info->width, info->height, info->stride,
- info->bitmap);
-}
-
-void glc_clip_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
- int stride, const uint8_t *bitmap, GLCClipOp op)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- FillMaskInfo mask_info;
-
- ASSERT(ctx && bitmap);
- mask_info.x_dest = x_dest;
- mask_info.y_dest = y_dest;
- mask_info.width = width;
- mask_info.height = height;
- mask_info.stride = stride;
- mask_info.bitmap = bitmap;
- clip_common(ctx, op, __fill_mask, &mask_info);
-}
-
-static inline void start_draw(InternaCtx *ctx)
-{
- if (ctx->draw_mode) {
- return;
- }
- ctx->draw_mode = TRUE;
- glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- glStencilFunc(GL_EQUAL, ctx->stencil_mask, ctx->stencil_mask);
- glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
- if (ctx->pat) {
- glEnable(GL_TEXTURE_2D);
- } else {
- glDisable(GL_TEXTURE_2D);
- }
- GLC_ERROR_TEST_FLUSH;
-}
-
-static void fill_rect(InternaCtx *ctx, void *r)
-{
- GLCRect *rect = (GLCRect *)r;
- glRectd(rect->x, Y(rect->y), rect->x + rect->width, Y(rect->y + rect->height));
- /*glBegin(GL_POLYGON);
- VERTEX2(rect->x, rect->y);
- VERTEX2 (rect->x + rect->width, rect->y);
- VERTEX2 (rect->x + rect->width, rect->y + rect->height);
- VERTEX2 (rect->x , rect->y + rect->height);
- glEnd();*/
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_fill_rect(GLCCtx glc, const GLCRect *rect)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- GLCRect *r = (GLCRect *)rect; // to avoid bugs in gcc older than 4.3
-
- ASSERT(ctx);
- start_draw(ctx);
- fill_rect(ctx, (void *)r);
- GLC_ERROR_TEST_FLUSH;
-}
-
-static void fill_path(InternaCtx *ctx, void *p)
-{
- InternalPath *path = (InternalPath *)p;
-
- PathPoint *current_point = path->points;
- PathSegment *current_segment = path->segments;
- Path *current_path = path->paths;
- Path *end_path = current_path + path->paths_pos;
- reset_tass_vertex(ctx);
- gluTessBeginPolygon(ctx->tesselator, ctx);
- for (; current_path < end_path; current_path++) {
- gluTessBeginContour(ctx->tesselator);
- PathSegment *end_segment = current_segment + current_path->num_segments;
- gluTessVertex(ctx->tesselator, (GLdouble *)current_point, current_point);
- current_point++;
- for (; current_segment < end_segment; current_segment++) {
- PathPoint *end_point;
- if (current_segment->type == GLC_PATH_SEG_BEIZER) {
- end_point = current_point + current_segment->count * 3;
- for (; current_point < end_point; current_point += 3) {
- TassVertex *vertex = bezier_flattener(ctx, current_point - 1);
- while (vertex) {
- gluTessVertex(ctx->tesselator, (GLdouble *)&vertex->point,
- (GLdouble *)&vertex->point);
- vertex = vertex->list_link;
- }
- gluTessVertex(ctx->tesselator, (GLdouble *)¤t_point[2],
- (GLdouble *)¤t_point[2]);
- }
- } else {
- ASSERT(current_segment->type == GLC_PATH_SEG_LINES);
- end_point = current_point + current_segment->count;
- for (; current_point < end_point; current_point++) {
- gluTessVertex(ctx->tesselator, (GLdouble *)current_point,
- (GLdouble *)current_point);
- }
- }
- }
- gluTessEndContour(ctx->tesselator);
- }
- gluTessEndPolygon(ctx->tesselator);
-}
-
-void glc_fill_path(GLCCtx glc, GLCPath path_ref)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx && path_ref);
- start_draw(ctx);
- fill_path(ctx, path_ref);
-}
-
-static void fill_mask(InternaCtx *ctx, int x_dest, int y_dest, int width, int height,
- int stride, const uint8_t *bitmap)
-{
- set_raster_pos(ctx, x_dest, y_dest + height);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, stride * 8);
- glBitmap(width, height, 0, 0, 0, 0, bitmap);
-}
-
-void _glc_fill_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
- const uint8_t *bitmap)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx && bitmap);
- start_draw(ctx);
- if (ctx->pat) {
- WARN_ONCE("%s: unimplemented fill mask with pattern\n", __FUNCTION__);
- }
- fill_mask(ctx, x_dest, y_dest, width, height, stride, bitmap);
-}
-
-void glc_fill_alpha(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
- const uint8_t *alpha_mask)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- GLCRect r;
-
- ASSERT(ctx);
- start_draw(ctx);
-
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
- set_raster_pos(ctx, x_dest, y_dest + height);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
- glPixelZoom(1, 1);
- glDrawPixels(width, height, GL_ALPHA, GL_UNSIGNED_BYTE, alpha_mask);
-
- r.x = x_dest;
- r.y = y_dest;
- r.width = width;
- r.height = height;
-
- //todo: support color/texture alpah vals (GL_MODULATE)
- glEnable(GL_BLEND);
- glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
- glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- fill_rect(ctx, &r);
- glDisable(GL_BLEND);
-}
-
-void glc_stroke_rect(GLCCtx glc, const GLCRect *rect)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx);
- if (ctx->line_width == 0) {
- return;
- }
-
- start_draw(ctx);
-
- glBegin(GL_LINES);
- VERTEX2(rect->x, rect->y + 0.5);
- VERTEX2(rect->x + rect->width, rect->y + 0.5);
- VERTEX2(rect->x + rect->width - 0.5, rect->y);
- VERTEX2(rect->x + rect->width - 0.5, rect->y + rect->height);
- VERTEX2(rect->x + rect->width, rect->y + rect->height - 0.5);
- VERTEX2(rect->x, rect->y + rect->height - 0.5);
- VERTEX2(rect->x + 0.5, rect->y + rect->height);
- VERTEX2(rect->x + 0.5, rect->y);
- glEnd();
- GLC_ERROR_TEST_FLUSH;
-}
-
-static void glc_stroke_line(double x1, double y1, double x2, double y2, double width)
-{
- double ax, ay, bx, by, cx, cy, dx, dy;
- double norm, tx;
-
- if (width == 1 || y1 == y2 || x1 == x2) {
- glBegin(GL_LINES);
- glVertex2d(x1, y1);
- glVertex2d(x2, y2);
- glEnd();
- return;
- }
- norm = (x1 - x2) / (y2 - y1);
- tx = width / (2 * sqrt(1 + norm * norm));
- ax = x1 + tx;
- ay = y1 + norm * (ax - x1);
- bx = x2 + tx;
- by = y2 + norm * (bx - x2);
- cx = x2 - tx;
- cy = y2 + norm * (cx - x2);
- dx = x1 - tx;
- dy = y1 + norm * (dx - x1);
- glBegin(GL_POLYGON);
- glVertex2d(ax, ay);
- glVertex2d(bx, by);
- glVertex2d(cx, cy);
- glVertex2d(dx, dy);
- glEnd();
-}
-
-static double glc_stroke_line_dash(double x1, double y1, double x2, double y2,
- double width, LineDash *dash)
-{
- double ax, ay, bx, by;
- double mx, my, len;
- double dash_len, total = 0;
-
- len = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
- if (!dash->dashes || !dash->num_dashes) {
- glc_stroke_line(x1, y1, x2, y2, width);
- return len;
- }
- mx = (x2 - x1) / len;
- my = (y2 - y1) / len;
- ax = x1;
- ay = y1;
- while (total < len) {
- if (dash->cur_dash >= 0) {
- dash_len = dash->dashes[dash->cur_dash % dash->num_dashes] - dash->dash_pos;
- } else {
- dash_len = dash->offset - dash->dash_pos;
- }
- total += dash_len;
- if (total < len) {
- bx = x1 + mx * total;
- by = y1 + my * total;
- dash->dash_pos = 0;
- } else {
- bx = x2;
- by = y2;
- dash->dash_pos = dash->dashes[dash->cur_dash % dash->num_dashes] - (total - len);
- }
- if (dash->cur_dash % 2 == 0) {
- glc_stroke_line(ax, ay, bx, by, width);
- }
- if (dash->dash_pos == 0) {
- dash->cur_dash = (dash->cur_dash + 1) % (2 * dash->num_dashes);
- }
- ax = bx;
- ay = by;
- }
- return len;
-}
-
-static void glc_vertex2d(InternaCtx *ctx, double x, double y)
-{
- if (ctx->path_stroke.state == GLC_STROKE_ACTIVE) {
- glc_stroke_line_dash(ctx->path_stroke.x, ctx->path_stroke.y, x, y,
- ctx->line_width, &ctx->line_dash);
- ctx->path_stroke.x = x;
- ctx->path_stroke.y = y;
- } else if (ctx->path_stroke.state == GLC_STROKE_FIRST) {
- ctx->path_stroke.x = x;
- ctx->path_stroke.y = y;
- ctx->path_stroke.state = GLC_STROKE_ACTIVE;
- } else {
- ASSERT(ctx->path_stroke.state == GLC_STROKE_NONACTIVE);
- //error
- }
-}
-
-static void glc_begin_path(InternaCtx *ctx)
-{
- ctx->path_stroke.state = GLC_STROKE_FIRST;
- ctx->line_dash.cur_dash = ctx->line_dash.offset ? -1 : 0;
- ctx->line_dash.dash_pos = 0;
-}
-
-static void glc_end_path(InternaCtx *ctx)
-{
- ctx->path_stroke.state = GLC_STROKE_NONACTIVE;
-}
-
-void glc_stroke_path(GLCCtx glc, GLCPath path_ref)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- InternalPath *path = (InternalPath *)path_ref;
-
- ASSERT(ctx && path);
- if (ctx->line_width == 0) {
- return;
- }
- start_draw(ctx);
-
- reset_tass_vertex(ctx);
- PathPoint *current_point = path->points;
- PathSegment *current_segment = path->segments;
- Path *current_path = path->paths;
- Path *end_path = current_path + path->paths_pos;
- for (; current_path < end_path; current_path++) {
- glc_begin_path(ctx);
- PathSegment *end_segment = current_segment + current_path->num_segments;
- glc_vertex2d(ctx, current_point->x, current_point->y);
- current_point++;
- for (; current_segment < end_segment; current_segment++) {
- PathPoint *end_point;
- if (current_segment->type == GLC_PATH_SEG_BEIZER) {
- end_point = current_point + current_segment->count * 3;
- for (; current_point < end_point; current_point += 3) {
- TassVertex *vertex = bezier_flattener(ctx, current_point - 1);
- while (vertex) {
- glc_vertex2d(ctx, vertex->point.x, vertex->point.y);
- vertex = vertex->list_link;
- }
- glc_vertex2d(ctx, current_point[2].x, current_point[2].y);
- }
- } else {
- ASSERT(current_segment->type == GLC_PATH_SEG_LINES);
- end_point = current_point + current_segment->count;
- for (; current_point < end_point; current_point++) {
- glc_vertex2d(ctx, current_point->x, current_point->y);
- }
- }
- }
- glc_end_path(ctx);
- }
-}
-
-void glc_draw_image(GLCCtx glc, const GLCRecti *dest, const GLCRecti *src, const GLCImage *image,
- int scale_mode, double alpha)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- uint8_t *pixels;
- const int pix_bytes = 4;
-
- ASSERT(ctx && image);
- ASSERT(src->width > 0 && src->height > 0);
-
- ASSERT(image->format == GLC_IMAGE_RGB32 || image->format == GLC_IMAGE_ARGB32); //for now
- start_draw(ctx);
- if (ctx->pat) {
- glDisable(GL_TEXTURE_2D);
- }
- set_raster_pos(ctx, dest->x, dest->y + dest->height);
-
- if (dest->width == src->width && src->height == dest->height) {
- glPixelZoom(1, 1);
- } else {
- glPixelZoom((float)dest->width / src->width, (float)dest->height / src->height);
- }
-
- pixels = image->pixels + src->x * 4 + (image->height - (src->y + src->height)) * image->stride;
- if (image->format == GLC_IMAGE_ARGB32 || alpha != 1) {
- glPixelTransferf(GL_ALPHA_SCALE, (GLfloat)alpha);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glEnable(GL_BLEND);
- }
- ASSERT(image->stride % pix_bytes == 0);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, image->stride / pix_bytes);
- glDrawPixels(src->width, src->height, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
-
- if (image->format == GLC_IMAGE_ARGB32 || alpha != 1) {
- glDisable(GL_BLEND);
- }
-
- if (ctx->pat) {
- glEnable(GL_TEXTURE_2D);
- }
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_copy_pixels(GLCCtx glc, int x_dest, int y_dest, int x_src, int y_src, int width,
- int height)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
- int recreate = 0;
-
- ASSERT(ctx);
-#ifdef USE_COPY_PIXELS
- start_draw(ctx);
- if (ctx->pat) {
- glDisable(GL_TEXTURE_2D);
- }
- set_raster_pos(ctx, x_dest, y_dest + height);
- glPixelZoom(1, 1);
- glCopyPixels(x_src, ctx->height - (y_src + height), width, height, GL_COLOR);
- if (ctx->pat) {
- glEnable(GL_TEXTURE_2D);
- }
-#else
- int width2 = gl_get_to_power_two(width);
- int height2 = gl_get_to_power_two(height);
-
- start_draw(ctx);
- glEnable(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D, 0);
-
- if (width2 > ctx->private_tex_width) {
- ctx->private_tex_width = width2;
- recreate = 1;
- }
- if (height2 > ctx->private_tex_height) {
- ctx->private_tex_height = height2;
- recreate = 1;
- }
- if (recreate) {
- glDeleteTextures(1, &ctx->private_tex);
- glGenTextures(1, &ctx->private_tex);
- glBindTexture(GL_TEXTURE_2D, ctx->private_tex);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
- ctx->private_tex_width = gl_get_to_power_two(width);
- ctx->private_tex_height = gl_get_to_power_two(height);
- glTexImage2D(GL_TEXTURE_2D, 0, 4, ctx->private_tex_width,
- ctx->private_tex_height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
- }
- ASSERT(ctx->private_tex);
- glBindTexture(GL_TEXTURE_2D, ctx->private_tex);
- glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, x_src, ctx->height - (y_src + height),
- width2, height2, 0);
-
- GLfloat s_gen_params[] = { (GLfloat)1.0 / width2, 0, 0, 0 };
- GLfloat t_gen_params[] = { 0, (GLfloat)1.0 / height2, 0, 0 };
- glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
- glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);
-
- glMatrixMode(GL_TEXTURE);
- glLoadIdentity();
- glTranslatef((float)-x_dest / width2, (float)-Y(y_dest + height) / height2, 0);
-
- glRecti(x_dest, Y(y_dest), x_dest + width, Y(y_dest + height));
- glFlush();
- if (!ctx->pat) {
- glDisable(GL_TEXTURE_2D);
- } else {
- set_pat(ctx, ctx->pat);
- }
-#endif
- GLC_ERROR_TEST_FLUSH;
-}
-
-void glc_read_pixels(GLCCtx glc, int x, int y, GLCImage *image)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx && image);
- ASSERT(image->format == GLC_IMAGE_RGB32); //for now
- ASSERT((image->stride % 4) == 0); //for now
- glPixelStorei(GL_PACK_ROW_LENGTH, image->stride / 4);
- glReadPixels(x, ctx->height - (y + image->height), image->width, image->height,
- GL_BGRA, GL_UNSIGNED_BYTE, image->pixels);
-}
-
-void glc_clear(GLCCtx glc)
-{
- InternaCtx *ctx = (InternaCtx *)glc;
-
- ASSERT(ctx);
- glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- glClear(GL_COLOR_BUFFER_BIT);
-}
-
-void glc_flush(GLCCtx glc)
-{
- glFlush();
-
- GLC_ERROR_TEST_FLUSH;
-}
-
-static void tessellation_combine(GLdouble coords[3], GLdouble *vertex_data[4], GLfloat weight[4],
- GLdouble **data_out, void *usr_data)
-{
- TassVertex *vertex;
-
- vertex = alloc_tess_vertex((InternaCtx *)usr_data);
- vertex->point.x = coords[0];
- vertex->point.y = coords[1];
- //vertex->point.z = coords[2];
- *data_out = (GLdouble *)&vertex->point;
-}
-
-static void tessellation_error(GLenum errorCode)
-{
- printf("%s: %s\n", __FUNCTION__, gluErrorString(errorCode));
-}
-
-#ifdef WIN32
-#define TESS_CALL_BACK_TYPE void(CALLBACK *)()
-#else
-#define TESS_CALL_BACK_TYPE void(*)()
-#endif
-
-static int init(InternaCtx *ctx, int width, int height)
-{
-#ifdef WIN32
- if (!(ctx->glBlendEquation = (PFNGLBLENDEQUATIONPROC)wglGetProcAddress("glBlendEquation"))) {
- return FALSE;
- }
-#endif
- ctx->width = width;
- ctx->height = height;
- ctx->line_width = 1;
-
- glClearColor(0, 0, 0, 0);
- glClearStencil(0);
-
- if (!(ctx->tesselator = gluNewTess())) {
- return FALSE;
- }
-
- glGenTextures(1, &ctx->private_tex);
- glBindTexture(GL_TEXTURE_2D, ctx->private_tex);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
- glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_get_to_power_two(width),
- gl_get_to_power_two(height), 0,
- GL_BGRA, GL_UNSIGNED_BYTE, NULL);
- ctx->private_tex_width = gl_get_to_power_two(width);
- ctx->private_tex_height = gl_get_to_power_two(height);
- glBindTexture(GL_TEXTURE_2D, 0);
-
- glViewport(0, 0, width, height);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, width, 0, height, -1, 1);
-
- gluTessProperty(ctx->tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
- gluTessCallback(ctx->tesselator, GLU_BEGIN, (TESS_CALL_BACK_TYPE)glBegin);
- gluTessCallback(ctx->tesselator, GLU_VERTEX, (TESS_CALL_BACK_TYPE)glVertex3dv);
- gluTessCallback(ctx->tesselator, GLU_END, (TESS_CALL_BACK_TYPE)glEnd);
- gluTessCallback(ctx->tesselator, GLU_TESS_COMBINE_DATA,
- (TESS_CALL_BACK_TYPE)tessellation_combine);
- gluTessCallback(ctx->tesselator, GLU_TESS_ERROR, (TESS_CALL_BACK_TYPE)tessellation_error);
-
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
- glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
- glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
- glEnable(GL_TEXTURE_GEN_S);
- glEnable(GL_TEXTURE_GEN_T);
-
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glTranslatef(0, (GLfloat)height, 0);
-
- glGetIntegerv(GL_MAX_TEXTURE_SIZE, &ctx->max_texture_size);
-
- glPixelStorei(GL_PACK_ALIGNMENT, 1);
-
- glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
- glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
- glPixelTransferf(GL_ALPHA_BIAS, 0);
-#ifdef WIN32
- ctx->glBlendEquation(GL_FUNC_ADD);
-#else
- glBlendEquation(GL_FUNC_ADD);
-#endif
-
- glStencilMask(0xff);
- glClear(GL_STENCIL_BUFFER_BIT);
-
- glClear(GL_COLOR_BUFFER_BIT);
-
- return TRUE;
-}
-
-GLCCtx glc_create(int width, int height)
-{
- InternaCtx *ctx;
-
- ASSERT(sizeof(PathPoint) == sizeof(Vertex));
-
- ctx = spice_new0(InternaCtx, 1);
- if (!init(ctx, width, height)) {
- free(ctx);
- return NULL;
- }
- return ctx;
-}
-
-/*
- * In glx video mode change the textures will be destroyed, therefore
- * if we will try to glDeleteTextures() them we might get seagfault.
- * (this why we use the textures_lost parameter)
- */
-void glc_destroy(GLCCtx glc, int textures_lost)
-{
- InternaCtx *ctx;
-
- if (!(ctx = (InternaCtx *)glc)) {
- return;
- }
-
- if (!textures_lost) {
- unref_pat(ctx->pat);
- ctx->pat = NULL;
- if (ctx->private_tex) {
- glDeleteTextures(1, &ctx->private_tex);
- }
- }
-
- free_tass_vertex_bufs(ctx);
- free(ctx->line_dash.dashes);
- free(ctx);
- GLC_ERROR_TEST_FINISH;
-}
-
-/*
- todo:
- 1. test double vs float in gl calls
- 2. int vs flat raster position
- 3. pixels stride vs bytes stride
- 4. improve non power of two.
- glGetString(GL_EXTENSIONS);
- ARB_texture_non_power_of_two
- ARB_texture_rectangle
- GL_TEXTURE_RECTANGLE_ARB
- 5. scale
- 6. origin
- 7. fonts
- 8. support more image formats
- 9. use GLCImage in mask ops?
-*/
diff --git a/common/glc.h b/common/glc.h
deleted file mode 100644
index d77f003..0000000
--- a/common/glc.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
-
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#ifndef _H_GL_CANVASE
-#define _H_GL_CANVASE
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void * GLCCtx;
-typedef void * GLCPattern;
-typedef void * GLCPath;
-
-typedef struct GLCRect {
- double x;
- double y;
- double width;
- double height;
-} GLCRect;
-
-typedef struct GLCRecti {
- int x;
- int y;
- int width;
- int height;
-} GLCRecti;
-
-typedef enum {
- GLC_IMAGE_RGB32,
- GLC_IMAGE_ARGB32,
-} GLCImageFormat;
-
-typedef struct GLCPImage {
- GLCImageFormat format;
- int width;
- int height;
- int stride;
- uint8_t *pixels;
- uint32_t *pallet;
-} GLCImage;
-
-GLCPattern glc_pattern_create(GLCCtx glc, int x_orign, int y_orign, const GLCImage *image);
-void glc_pattern_set(GLCPattern pattern, int x_orign, int y_orign, const GLCImage *image);
-void glc_pattern_destroy(GLCPattern pattern);
-
-void glc_path_move_to(GLCPath path, double x, double y);
-void glc_path_line_to(GLCPath path, double x, double y);
-void glc_path_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
- double p3_x, double p3_y);
-void glc_path_rel_move_to(GLCPath path, double x, double y);
-void glc_path_rel_line_to(GLCPath path, double x, double y);
-void glc_path_rel_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
- double p3_x, double p3_y);
-void glc_path_close(GLCPath path);
-
-void glc_path_cleare(GLCPath);
-GLCPath glc_path_create(GLCCtx glc);
-void glc_path_destroy(GLCPath path);
-
-void glc_set_rgb(GLCCtx glc, double red, double green, double blue);
-void glc_set_rgba(GLCCtx glc, double red, double green, double blue, double alpha);
-void glc_set_pattern(GLCCtx glc, GLCPattern pattern);
-
-typedef enum {
- GLC_OP_CLEAR = 0x1500,
- GLC_OP_SET = 0x150F,
- GLC_OP_COPY = 0x1503,
- GLC_OP_COPY_INVERTED = 0x150C,
- GLC_OP_NOOP = 0x1505,
- GLC_OP_INVERT = 0x150A,
- GLC_OP_AND = 0x1501,
- GLC_OP_NAND = 0x150E,
- GLC_OP_OR = 0x1507,
- GLC_OP_NOR = 0x1508,
- GLC_OP_XOR = 0x1506,
- GLC_OP_EQUIV = 0x1509,
- GLC_OP_AND_REVERSE = 0x1502,
- GLC_OP_AND_INVERTED = 0x1504,
- GLC_OP_OR_REVERSE = 0x150B,
- GLC_OP_OR_INVERTED = 0x150D,
-} GLCOp;
-
-void glc_set_op(GLCCtx glc, GLCOp op);
-void glc_set_alpha_factor(GLCCtx glc, double alpah);
-
-typedef enum {
- GLC_FILL_MODE_WINDING_ODD,
- GLC_FILL_MODE_WINDING_NONZERO,
-} GLCFillMode;
-
-void glc_set_fill_mode(GLCCtx glc, GLCFillMode mode);
-void glc_set_line_width(GLCCtx glc, double width);
-void glc_set_line_end_cap(GLCCtx glc, int style);
-void glc_set_line_join(GLCCtx glc, int style);
-void glc_set_miter_limit(GLCCtx glc, int limit);
-void glc_set_line_dash(GLCCtx glc, const double *dashes, int num_dashes, double offset);
-
-typedef enum {
- GLC_MASK_A,
- GLC_MASK_B,
-} GLCMaskID;
-
-void glc_set_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
- int stride, const uint8_t *bitmap, GLCMaskID id);
-void glc_mask_rects(GLCCtx glc, int num_rect, GLCRect *rects, GLCMaskID id);
-void glc_clear_mask(GLCCtx glc, GLCMaskID id);
-
-typedef enum {
- GLC_CLIP_OP_SET,
- GLC_CLIP_OP_OR,
- GLC_CLIP_OP_AND,
- GLC_CLIP_OP_EXCLUDE,
-} GLCClipOp;
-
-void glc_clip_rect(GLCCtx glc, const GLCRect *rect, GLCClipOp op);
-void glc_clip_path(GLCCtx glc, GLCPath path, GLCClipOp op);
-void glc_clip_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
- const uint8_t *bitmap, GLCClipOp op);
-void glc_clip_reset(GLCCtx glc);
-
-void glc_fill_rect(GLCCtx glc, const GLCRect *rect);
-void glc_fill_path(GLCCtx glc, GLCPath path);
-void _glc_fill_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
- const uint8_t *bitmap);
-void glc_fill_alpha(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
- const uint8_t *alpha_mask);
-
-void glc_stroke_rect(GLCCtx glc, const GLCRect *rect);
-void glc_stroke_path(GLCCtx glc, GLCPath path);
-
-void glc_draw_image(GLCCtx glc, const GLCRecti *dest, const GLCRecti *src, const GLCImage *image,
- int scale_mode, double alpha);
-
-void glc_copy_pixels(GLCCtx glc, int x_dest, int y_dest, int x_src, int y_src, int width,
- int height);
-void glc_read_pixels(GLCCtx glc, int x, int y, GLCImage *image);
-
-void glc_flush(GLCCtx glc);
-void glc_clear(GLCCtx glc);
-GLCCtx glc_create(int width, int height);
-void glc_destroy(GLCCtx glc, int textures_lost);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/lines.c b/common/lines.c
deleted file mode 100644
index 797d5d6..0000000
--- a/common/lines.c
+++ /dev/null
@@ -1,3613 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/***********************************************************
-
-Copyright 1989, 1998 The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-
-Copyright 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
-
- All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-******************************************************************/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include <spice/macros.h>
-#ifdef _XOPEN_SOURCE
-#include <math.h>
-#else
-#define _XOPEN_SOURCE /* to get prototype for hypot on some systems */
-#include <math.h>
-#undef _XOPEN_SOURCE
-#endif
-#include "lines.h"
-#include "mem.h"
-
-#define xalloc(i) spice_malloc(i)
-#define xrealloc(a,b) spice_realloc(a,b)
-#define xfree(i) free(i)
-
-typedef unsigned int CARD32;
-typedef int Boolean;
-typedef pixman_rectangle32_t xRectangle;
-typedef SpicePoint DDXPointRec;
-typedef DDXPointRec *DDXPointPtr;
-typedef struct lineGC *GCPtr;
-
-/* largest positive value that can fit into a component of a point.
- * Assumes that the point structure is {type x, y;} where type is
- * a signed type.
- */
-#define MAX_COORDINATE 2147483647
-#define MIN_COORDINATE -2147483647
-
-#define miZeroLine spice_canvas_zero_line
-#define miZeroDashLine spice_canvas_zero_dash_line
-#define miWideDash spice_canvas_wide_dash_line
-#define miWideLine spice_canvas_wide_line
-
-static INLINE int ICEIL (double x)
-{
- int _cTmp = (int)x;
- return ((x == _cTmp) || (x < 0.0)) ? _cTmp : _cTmp + 1;
-}
-
-typedef struct {
- int count; /* number of spans */
- DDXPointPtr points; /* pointer to list of start points */
- int *widths; /* pointer to list of widths */
-} Spans;
-
-typedef struct {
- int size; /* Total number of *Spans allocated */
- int count; /* Number of *Spans actually in group */
- Spans *group; /* List of Spans */
- int ymin, ymax; /* Min, max y values encountered */
-} SpanGroup;
-
-/* Initialize SpanGroup. MUST BE DONE before use. */
-static void miInitSpanGroup (SpanGroup * /*spanGroup */
- );
-
-/* Add a Spans to a SpanGroup. The spans MUST BE in y-sorted order */
-static void miAppendSpans (SpanGroup * /*spanGroup */ ,
- SpanGroup * /*otherGroup */ ,
- Spans * /*spans */
- );
-
-/* Paint a span group, insuring that each pixel is painted at most once */
-static void miFillUniqueSpanGroup (GCPtr /*pGC */ ,
- SpanGroup * /*spanGroup */ ,
- Boolean /* foreground */
- );
-
-/* Free up data in a span group. MUST BE DONE or you'll suffer memory leaks */
-static void miFreeSpanGroup (SpanGroup * /*spanGroup */
- );
-
-/* Rops which must use span groups */
-#define miSpansCarefulRop(rop) (((rop) & 0xc) == 0x8 || ((rop) & 0x3) == 0x2)
-#define miSpansEasyRop(rop) (!miSpansCarefulRop(rop))
-
-/*
- * Public definitions used for configuring basic pixelization aspects
- * of the sample implementation line-drawing routines provided in
- * {mfb,mi,cfb*} at run-time.
- */
-
-#define XDECREASING 4
-#define YDECREASING 2
-#define YMAJOR 1
-
-#define OCTANT1 (1 << (YDECREASING))
-#define OCTANT2 (1 << (YDECREASING|YMAJOR))
-#define OCTANT3 (1 << (XDECREASING|YDECREASING|YMAJOR))
-#define OCTANT4 (1 << (XDECREASING|YDECREASING))
-#define OCTANT5 (1 << (XDECREASING))
-#define OCTANT6 (1 << (XDECREASING|YMAJOR))
-#define OCTANT7 (1 << (YMAJOR))
-#define OCTANT8 (1 << (0))
-
-#define XMAJOROCTANTS (OCTANT1 | OCTANT4 | OCTANT5 | OCTANT8)
-
-#define DEFAULTZEROLINEBIAS (OCTANT2 | OCTANT3 | OCTANT4 | OCTANT5)
-
-/*
- * Devices can configure the rendering of routines in mi, mfb, and cfb*
- * by specifying a thin line bias to be applied to a particular screen
- * using the following function. The bias parameter is an OR'ing of
- * the appropriate OCTANT constants defined above to indicate which
- * octants to bias a line to prefer an axial step when the Bresenham
- * error term is exactly zero. The octants are mapped as follows:
- *
- * \ | /
- * \ 3 | 2 /
- * \ | /
- * 4 \ | / 1
- * \|/
- * -----------
- * /|\
- * 5 / | \ 8
- * / | \
- * / 6 | 7 \
- * / | \
- *
- * For more information, see "Ambiguities in Incremental Line Rastering,"
- * Jack E. Bresenham, IEEE CG&A, May 1987.
- */
-
-/*
- * Private definitions needed for drawing thin (zero width) lines
- * Used by the mi, mfb, and all cfb* components.
- */
-
-#define X_AXIS 0
-#define Y_AXIS 1
-
-#define OUT_LEFT 0x08
-#define OUT_RIGHT 0x04
-#define OUT_ABOVE 0x02
-#define OUT_BELOW 0x01
-
-#define OUTCODES(_result, _x, _y, _pbox) \
- if ( (_x) < (_pbox)->x1) (_result) |= OUT_LEFT; \
- else if ( (_x) >= (_pbox)->x2) (_result) |= OUT_RIGHT; \
- if ( (_y) < (_pbox)->y1) (_result) |= OUT_ABOVE; \
- else if ( (_y) >= (_pbox)->y2) (_result) |= OUT_BELOW;
-
-#define MIOUTCODES(outcode, x, y, xmin, ymin, xmax, ymax) \
-{\
- if (x < xmin) outcode |= OUT_LEFT;\
- if (x > xmax) outcode |= OUT_RIGHT;\
- if (y < ymin) outcode |= OUT_ABOVE;\
- if (y > ymax) outcode |= OUT_BELOW;\
-}
-
-#define SWAPINT(i, j) \
-{ int _t = i; i = j; j = _t; }
-
-#define SWAPPT(i, j) \
-{ DDXPointRec _t; _t = i; i = j; j = _t; }
-
-#define SWAPINT_PAIR(x1, y1, x2, y2)\
-{ int t = x1; x1 = x2; x2 = t;\
- t = y1; y1 = y2; y2 = t;\
-}
-
-#define miGetZeroLineBias(_pScreen) (DEFAULTZEROLINEBIAS)
-
-#define CalcLineDeltas(_x1,_y1,_x2,_y2,_adx,_ady,_sx,_sy,_SX,_SY,_octant) \
- (_octant) = 0; \
- (_sx) = (_SX); \
- if (((_adx) = (_x2) - (_x1)) < 0) { \
- (_adx) = -(_adx); \
- (_sx = -(_sx)); \
- (_octant) |= XDECREASING; \
- } \
- (_sy) = (_SY); \
- if (((_ady) = (_y2) - (_y1)) < 0) { \
- (_ady) = -(_ady); \
- (_sy = -(_sy)); \
- (_octant) |= YDECREASING; \
- }
-
-#define SetYMajorOctant(_octant) ((_octant) |= YMAJOR)
-
-#define FIXUP_ERROR(_e, _octant, _bias) \
- (_e) -= (((_bias) >> (_octant)) & 1)
-
-#define IsXMajorOctant(_octant) (!((_octant) & YMAJOR))
-#define IsYMajorOctant(_octant) ((_octant) & YMAJOR)
-#define IsXDecreasingOctant(_octant) ((_octant) & XDECREASING)
-#define IsYDecreasingOctant(_octant) ((_octant) & YDECREASING)
-
-static int miZeroClipLine (int /*xmin */ ,
- int /*ymin */ ,
- int /*xmax */ ,
- int /*ymax */ ,
- int * /*new_x1 */ ,
- int * /*new_y1 */ ,
- int * /*new_x2 */ ,
- int * /*new_y2 */ ,
- unsigned int /*adx */ ,
- unsigned int /*ady */ ,
- int * /*pt1_clipped */ ,
- int * /*pt2_clipped */ ,
- int /*octant */ ,
- unsigned int /*bias */ ,
- int /*oc1 */ ,
- int /*oc2 */
- );
-
-/*
- * interface data to span-merging polygon filler
- */
-
-typedef struct _SpanData {
- SpanGroup fgGroup, bgGroup;
-} SpanDataRec, *SpanDataPtr;
-
-#define AppendSpanGroup(pGC, foreground, spanPtr, spanData) { \
- SpanGroup *group, *othergroup = NULL; \
- if (foreground) \
- { \
- group = &spanData->fgGroup; \
- if (pGC->lineStyle == LineDoubleDash) \
- othergroup = &spanData->bgGroup; \
- } \
- else \
- { \
- group = &spanData->bgGroup; \
- othergroup = &spanData->fgGroup; \
- } \
- miAppendSpans (group, othergroup, spanPtr); \
-}
-
-/*
- * Polygon edge description for integer wide-line routines
- */
-
-typedef struct _PolyEdge {
- int height; /* number of scanlines to process */
- int x; /* starting x coordinate */
- int stepx; /* fixed integral dx */
- int signdx; /* variable dx sign */
- int e; /* initial error term */
- int dy;
- int dx;
-} PolyEdgeRec, *PolyEdgePtr;
-
-#define SQSECANT 108.856472512142 /* 1/sin^2(11/2) - miter limit constant */
-
-/*
- * types for general polygon routines
- */
-
-typedef struct _PolyVertex {
- double x, y;
-} PolyVertexRec, *PolyVertexPtr;
-
-typedef struct _PolySlope {
- int dx, dy;
- double k; /* x0 * dy - y0 * dx */
-} PolySlopeRec, *PolySlopePtr;
-
-/*
- * Line face description for caps/joins
- */
-
-typedef struct _LineFace {
- double xa, ya;
- int dx, dy;
- int x, y;
- double k;
-} LineFaceRec, *LineFacePtr;
-
-/*
- * macros for polygon fillers
- */
-
-#define MIPOLYRELOADLEFT if (!left_height && left_count) { \
- left_height = left->height; \
- left_x = left->x; \
- left_stepx = left->stepx; \
- left_signdx = left->signdx; \
- left_e = left->e; \
- left_dy = left->dy; \
- left_dx = left->dx; \
- --left_count; \
- ++left; \
- }
-
-#define MIPOLYRELOADRIGHT if (!right_height && right_count) { \
- right_height = right->height; \
- right_x = right->x; \
- right_stepx = right->stepx; \
- right_signdx = right->signdx; \
- right_e = right->e; \
- right_dy = right->dy; \
- right_dx = right->dx; \
- --right_count; \
- ++right; \
- }
-
-#define MIPOLYSTEPLEFT left_x += left_stepx; \
- left_e += left_dx; \
- if (left_e > 0) \
- { \
- left_x += left_signdx; \
- left_e -= left_dy; \
- }
-
-#define MIPOLYSTEPRIGHT right_x += right_stepx; \
- right_e += right_dx; \
- if (right_e > 0) \
- { \
- right_x += right_signdx; \
- right_e -= right_dy; \
- }
-
-static void miRoundJoinClip (LineFacePtr /*pLeft */ ,
- LineFacePtr /*pRight */ ,
- PolyEdgePtr /*edge1 */ ,
- PolyEdgePtr /*edge2 */ ,
- int * /*y1 */ ,
- int * /*y2 */ ,
- Boolean * /*left1 */ ,
- Boolean * /*left2 */
- );
-
-static int miRoundCapClip (LineFacePtr /*face */ ,
- Boolean /*isInt */ ,
- PolyEdgePtr /*edge */ ,
- Boolean * /*leftEdge */
- );
-
-static int miPolyBuildEdge (double x0, double y0, double k, int dx, int dy,
- int xi, int yi, int left, PolyEdgePtr edge);
-static int miPolyBuildPoly (PolyVertexPtr vertices, PolySlopePtr slopes,
- int count, int xi, int yi, PolyEdgePtr left,
- PolyEdgePtr right, int *pnleft, int *pnright, int *h);
-
-
-static void
-miStepDash (int dist, /* distance to step */
- int *pDashIndex, /* current dash */
- unsigned char *pDash, /* dash list */
- int numInDashList, /* total length of dash list */
- int *pDashOffset /* offset into current dash */
- )
-{
- int dashIndex, dashOffset;
- int totallen;
- int i;
-
- dashIndex = *pDashIndex;
- dashOffset = *pDashOffset;
- if (dist < pDash[dashIndex] - dashOffset) {
- *pDashOffset = dashOffset + dist;
- return;
- }
- dist -= pDash[dashIndex] - dashOffset;
- if (++dashIndex == numInDashList)
- dashIndex = 0;
- totallen = 0;
- for (i = 0; i < numInDashList; i++)
- totallen += pDash[i];
- if (totallen <= dist)
- dist = dist % totallen;
- while (dist >= pDash[dashIndex]) {
- dist -= pDash[dashIndex];
- if (++dashIndex == numInDashList)
- dashIndex = 0;
- }
- *pDashIndex = dashIndex;
- *pDashOffset = dist;
-}
-
-/*
-
-These routines maintain lists of Spans, in order to implement the
-``touch-each-pixel-once'' rules of wide lines and arcs.
-
-Written by Joel McCormack, Summer 1989.
-
-*/
-
-
-static void
-miInitSpanGroup (SpanGroup * spanGroup)
-{
- spanGroup->size = 0;
- spanGroup->count = 0;
- spanGroup->group = NULL;
- spanGroup->ymin = MAX_COORDINATE;
- spanGroup->ymax = MIN_COORDINATE;
-} /* InitSpanGroup */
-
-#define YMIN(spans) (spans->points[0].y)
-#define YMAX(spans) (spans->points[spans->count-1].y)
-
-static void
-miSubtractSpans (SpanGroup * spanGroup, Spans * sub)
-{
- int i, subCount, spansCount;
- int ymin, ymax, xmin, xmax;
- Spans *spans;
- DDXPointPtr subPt, spansPt;
- int *subWid, *spansWid;
- int extra;
-
- ymin = YMIN (sub);
- ymax = YMAX (sub);
- spans = spanGroup->group;
- for (i = spanGroup->count; i; i--, spans++) {
- if (YMIN (spans) <= ymax && ymin <= YMAX (spans)) {
- subCount = sub->count;
- subPt = sub->points;
- subWid = sub->widths;
- spansCount = spans->count;
- spansPt = spans->points;
- spansWid = spans->widths;
- extra = 0;
- for (;;) {
- while (spansCount && spansPt->y < subPt->y) {
- spansPt++;
- spansWid++;
- spansCount--;
- }
- if (!spansCount)
- break;
- while (subCount && subPt->y < spansPt->y) {
- subPt++;
- subWid++;
- subCount--;
- }
- if (!subCount)
- break;
- if (subPt->y == spansPt->y) {
- xmin = subPt->x;
- xmax = xmin + *subWid;
- if (xmin >= spansPt->x + *spansWid || spansPt->x >= xmax) {
- ;
- } else if (xmin <= spansPt->x) {
- if (xmax >= spansPt->x + *spansWid) {
- memmove (spansPt, spansPt + 1, sizeof *spansPt * (spansCount - 1));
- memmove (spansWid, spansWid + 1, sizeof *spansWid * (spansCount - 1));
- spansPt--;
- spansWid--;
- spans->count--;
- extra++;
- } else {
- *spansWid = *spansWid - (xmax - spansPt->x);
- spansPt->x = xmax;
- }
- } else {
- if (xmax >= spansPt->x + *spansWid) {
- *spansWid = xmin - spansPt->x;
- } else {
- if (!extra) {
- DDXPointPtr newPt;
- int *newwid;
-
-#define EXTRA 8
- newPt = xrealloc (spans->points,
- (spans->count +
- EXTRA) * sizeof (DDXPointRec));
- if (!newPt)
- break;
- spansPt = newPt + (spansPt - spans->points);
- spans->points = newPt;
- newwid = xrealloc (spans->widths,
- (spans->count + EXTRA) * sizeof (int));
- if (!newwid)
- break;
- spansWid = newwid + (spansWid - spans->widths);
- spans->widths = newwid;
- extra = EXTRA;
- }
- memmove (spansPt + 1, spansPt, sizeof *spansPt * (spansCount));
- memmove (spansWid + 1, spansWid, sizeof *spansWid * (spansCount));
- spans->count++;
- extra--;
- *spansWid = xmin - spansPt->x;
- spansWid++;
- spansPt++;
- *spansWid = *spansWid - (xmax - spansPt->x);
- spansPt->x = xmax;
- }
- }
- }
- spansPt++;
- spansWid++;
- spansCount--;
- }
- }
- }
-}
-
-static void
-miAppendSpans (SpanGroup * spanGroup, SpanGroup * otherGroup, Spans * spans)
-{
- int ymin, ymax;
- int spansCount;
-
- spansCount = spans->count;
- if (spansCount > 0) {
- if (spanGroup->size == spanGroup->count) {
- spanGroup->size = (spanGroup->size + 8) * 2;
- spanGroup->group =
- xrealloc (spanGroup->group, sizeof (Spans) * spanGroup->size);
- }
-
- spanGroup->group[spanGroup->count] = *spans;
- (spanGroup->count)++;
- ymin = spans->points[0].y;
- if (ymin < spanGroup->ymin)
- spanGroup->ymin = ymin;
- ymax = spans->points[spansCount - 1].y;
- if (ymax > spanGroup->ymax)
- spanGroup->ymax = ymax;
- if (otherGroup && otherGroup->ymin < ymax && ymin < otherGroup->ymax) {
- miSubtractSpans (otherGroup, spans);
- }
- } else {
- xfree (spans->points);
- xfree (spans->widths);
- }
-} /* AppendSpans */
-
-static void
-miFreeSpanGroup (SpanGroup * spanGroup)
-{
- xfree (spanGroup->group);
-}
-
-static void
-QuickSortSpansX (DDXPointRec points[], int widths[], int numSpans)
-{
- int x;
- int i, j, m;
- DDXPointPtr r;
-
-/* Always called with numSpans > 1 */
-/* Sorts only by x, as all y should be the same */
-
-#define ExchangeSpans(a, b) \
-{ \
- DDXPointRec tpt; \
- int tw; \
- \
- tpt = points[a]; points[a] = points[b]; points[b] = tpt; \
- tw = widths[a]; widths[a] = widths[b]; widths[b] = tw; \
-}
-
- do {
- if (numSpans < 9) {
- /* Do insertion sort */
- int xprev;
-
- xprev = points[0].x;
- i = 1;
- do { /* while i != numSpans */
- x = points[i].x;
- if (xprev > x) {
- /* points[i] is out of order. Move into proper location. */
- DDXPointRec tpt;
- int tw, k;
-
- for (j = 0; x >= points[j].x; j++) {
- }
- tpt = points[i];
- tw = widths[i];
- for (k = i; k != j; k--) {
- points[k] = points[k - 1];
- widths[k] = widths[k - 1];
- }
- points[j] = tpt;
- widths[j] = tw;
- x = points[i].x;
- } /* if out of order */
- xprev = x;
- i++;
- } while (i != numSpans);
- return;
- }
-
- /* Choose partition element, stick in location 0 */
- m = numSpans / 2;
- if (points[m].x > points[0].x)
- ExchangeSpans (m, 0);
- if (points[m].x > points[numSpans - 1].x)
- ExchangeSpans (m, numSpans - 1);
- if (points[m].x > points[0].x)
- ExchangeSpans (m, 0);
- x = points[0].x;
-
- /* Partition array */
- i = 0;
- j = numSpans;
- do {
- r = &(points[i]);
- do {
- r++;
- i++;
- } while (i != numSpans && r->x < x);
- r = &(points[j]);
- do {
- r--;
- j--;
- } while (x < r->x);
- if (i < j)
- ExchangeSpans (i, j);
- } while (i < j);
-
- /* Move partition element back to middle */
- ExchangeSpans (0, j);
-
- /* Recurse */
- if (numSpans - j - 1 > 1)
- QuickSortSpansX (&points[j + 1], &widths[j + 1], numSpans - j - 1);
- numSpans = j;
- } while (numSpans > 1);
-} /* QuickSortSpans */
-
-
-static int
-UniquifySpansX (Spans * spans, DDXPointRec * newPoints, int *newWidths)
-{
- int newx1, newx2, oldpt, i, y;
- DDXPointRec *oldPoints;
- int *oldWidths;
- int *startNewWidths;
-
-/* Always called with numSpans > 1 */
-/* Uniquify the spans, and stash them into newPoints and newWidths. Return the
- number of unique spans. */
-
-
- startNewWidths = newWidths;
-
- oldPoints = spans->points;
- oldWidths = spans->widths;
-
- y = oldPoints->y;
- newx1 = oldPoints->x;
- newx2 = newx1 + *oldWidths;
-
- for (i = spans->count - 1; i != 0; i--) {
- oldPoints++;
- oldWidths++;
- oldpt = oldPoints->x;
- if (oldpt > newx2) {
- /* Write current span, start a new one */
- newPoints->x = newx1;
- newPoints->y = y;
- *newWidths = newx2 - newx1;
- newPoints++;
- newWidths++;
- newx1 = oldpt;
- newx2 = oldpt + *oldWidths;
- } else {
- /* extend current span, if old extends beyond new */
- oldpt = oldpt + *oldWidths;
- if (oldpt > newx2)
- newx2 = oldpt;
- }
- } /* for */
-
- /* Write final span */
- newPoints->x = newx1;
- *newWidths = newx2 - newx1;
- newPoints->y = y;
-
- return (newWidths - startNewWidths) + 1;
-} /* UniquifySpansX */
-
-static void
-miDisposeSpanGroup (SpanGroup * spanGroup)
-{
- int i;
- Spans *spans;
-
- for (i = 0; i < spanGroup->count; i++) {
- spans = spanGroup->group + i;
- xfree (spans->points);
- xfree (spans->widths);
- }
-}
-
-static void
-miFillUniqueSpanGroup (GCPtr pGC, SpanGroup * spanGroup, Boolean foreground)
-{
- int i;
- Spans *spans;
- Spans *yspans;
- int *ysizes;
- int ymin, ylength;
-
- /* Outgoing spans for one big call to FillSpans */
- DDXPointPtr points;
- int *widths;
- int count;
-
- if (spanGroup->count == 0)
- return;
-
- if (spanGroup->count == 1) {
- /* Already should be sorted, unique */
- spans = spanGroup->group;
- (*pGC->ops->FillSpans)
- (pGC, spans->count, spans->points, spans->widths, TRUE, foreground);
- xfree (spans->points);
- xfree (spans->widths);
- } else {
- /* Yuck. Gross. Radix sort into y buckets, then sort x and uniquify */
- /* This seems to be the fastest thing to do. I've tried sorting on
- both x and y at the same time rather than creating into all those
- y buckets, but it was somewhat slower. */
-
- ymin = spanGroup->ymin;
- ylength = spanGroup->ymax - ymin + 1;
-
- /* Allocate Spans for y buckets */
- yspans = (Spans*)xalloc (ylength * sizeof (Spans));
- ysizes = (int *)xalloc (ylength * sizeof (int));
-
- if (!yspans || !ysizes) {
- xfree (yspans);
- xfree (ysizes);
- miDisposeSpanGroup (spanGroup);
- return;
- }
-
- for (i = 0; i != ylength; i++) {
- ysizes[i] = 0;
- yspans[i].count = 0;
- yspans[i].points = NULL;
- yspans[i].widths = NULL;
- }
-
- /* Go through every single span and put it into the correct bucket */
- count = 0;
- for (i = 0, spans = spanGroup->group; i != spanGroup->count; i++, spans++) {
- int index;
- int j;
-
- for (j = 0, points = spans->points, widths = spans->widths;
- j != spans->count; j++, points++, widths++) {
- index = points->y - ymin;
- if (index >= 0 && index < ylength) {
- Spans *newspans = &(yspans[index]);
- if (newspans->count == ysizes[index]) {
- DDXPointPtr newpoints;
- int *newwidths;
- ysizes[index] = (ysizes[index] + 8) * 2;
- newpoints = xrealloc (newspans->points,
- ysizes[index] * sizeof (DDXPointRec));
- newwidths = xrealloc (newspans->widths,
- ysizes[index] * sizeof (int));
- if (!newpoints || !newwidths) {
- int i;
-
- for (i = 0; i < ylength; i++) {
- xfree (yspans[i].points);
- xfree (yspans[i].widths);
- }
- xfree (yspans);
- xfree (ysizes);
- miDisposeSpanGroup (spanGroup);
- return;
- }
- newspans->points = newpoints;
- newspans->widths = newwidths;
- }
- newspans->points[newspans->count] = *points;
- newspans->widths[newspans->count] = *widths;
- (newspans->count)++;
- } /* if y value of span in range */
- } /* for j through spans */
- count += spans->count;
- xfree (spans->points);
- spans->points = NULL;
- xfree (spans->widths);
- spans->widths = NULL;
- } /* for i thorough Spans */
-
- /* Now sort by x and uniquify each bucket into the final array */
- points = (DDXPointRec*)xalloc (count * sizeof (DDXPointRec));
- widths = (int *)xalloc (count * sizeof (int));
- if (!points || !widths) {
- int i;
-
- for (i = 0; i < ylength; i++) {
- xfree (yspans[i].points);
- xfree (yspans[i].widths);
- }
- xfree (yspans);
- xfree (ysizes);
- xfree (points);
- xfree (widths);
- return;
- }
- count = 0;
- for (i = 0; i != ylength; i++) {
- int ycount = yspans[i].count;
- if (ycount > 0) {
- if (ycount > 1) {
- QuickSortSpansX (yspans[i].points, yspans[i].widths, ycount);
- count += UniquifySpansX (&(yspans[i]), &(points[count]), &(widths[count]));
- } else {
- points[count] = yspans[i].points[0];
- widths[count] = yspans[i].widths[0];
- count++;
- }
- xfree (yspans[i].points);
- xfree (yspans[i].widths);
- }
- }
-
- (*pGC->ops->FillSpans) (pGC, count, points, widths, TRUE, foreground);
- xfree (points);
- xfree (widths);
- xfree (yspans);
- xfree (ysizes); /* use (DE)xalloc for these? */
- }
-
- spanGroup->count = 0;
- spanGroup->ymin = MAX_COORDINATE;
- spanGroup->ymax = MIN_COORDINATE;
-}
-
-/*
-
-The bresenham error equation used in the mi/mfb/cfb line routines is:
-
- e = error
- dx = difference in raw X coordinates
- dy = difference in raw Y coordinates
- M = # of steps in X direction
- N = # of steps in Y direction
- B = 0 to prefer diagonal steps in a given octant,
- 1 to prefer axial steps in a given octant
-
- For X major lines:
- e = 2Mdy - 2Ndx - dx - B
- -2dx <= e < 0
-
- For Y major lines:
- e = 2Ndx - 2Mdy - dy - B
- -2dy <= e < 0
-
-At the start of the line, we have taken 0 X steps and 0 Y steps,
-so M = 0 and N = 0:
-
- X major e = 2Mdy - 2Ndx - dx - B
- = -dx - B
-
- Y major e = 2Ndx - 2Mdy - dy - B
- = -dy - B
-
-At the end of the line, we have taken dx X steps and dy Y steps,
-so M = dx and N = dy:
-
- X major e = 2Mdy - 2Ndx - dx - B
- = 2dxdy - 2dydx - dx - B
- = -dx - B
- Y major e = 2Ndx - 2Mdy - dy - B
- = 2dydx - 2dxdy - dy - B
- = -dy - B
-
-Thus, the error term is the same at the start and end of the line.
-
-Let us consider clipping an X coordinate. There are 4 cases which
-represent the two independent cases of clipping the start vs. the
-end of the line and an X major vs. a Y major line. In any of these
-cases, we know the number of X steps (M) and we wish to find the
-number of Y steps (N). Thus, we will solve our error term equation.
-If we are clipping the start of the line, we will find the smallest
-N that satisfies our error term inequality. If we are clipping the
-end of the line, we will find the largest number of Y steps that
-satisfies the inequality. In that case, since we are representing
-the Y steps as (dy - N), we will actually want to solve for the
-smallest N in that equation.
-
-Case 1: X major, starting X coordinate moved by M steps
-
- -2dx <= 2Mdy - 2Ndx - dx - B < 0
- 2Ndx <= 2Mdy - dx - B + 2dx 2Ndx > 2Mdy - dx - B
- 2Ndx <= 2Mdy + dx - B N > (2Mdy - dx - B) / 2dx
- N <= (2Mdy + dx - B) / 2dx
-
-Since we are trying to find the smallest N that satisfies these
-equations, we should use the > inequality to find the smallest:
-
- N = floor((2Mdy - dx - B) / 2dx) + 1
- = floor((2Mdy - dx - B + 2dx) / 2dx)
- = floor((2Mdy + dx - B) / 2dx)
-
-Case 1b: X major, ending X coordinate moved to M steps
-
-Same derivations as Case 1, but we want the largest N that satisfies
-the equations, so we use the <= inequality:
-
- N = floor((2Mdy + dx - B) / 2dx)
-
-Case 2: X major, ending X coordinate moved by M steps
-
- -2dx <= 2(dx - M)dy - 2(dy - N)dx - dx - B < 0
- -2dx <= 2dxdy - 2Mdy - 2dxdy + 2Ndx - dx - B < 0
- -2dx <= 2Ndx - 2Mdy - dx - B < 0
- 2Ndx >= 2Mdy + dx + B - 2dx 2Ndx < 2Mdy + dx + B
- 2Ndx >= 2Mdy - dx + B N < (2Mdy + dx + B) / 2dx
- N >= (2Mdy - dx + B) / 2dx
-
-Since we are trying to find the highest number of Y steps that
-satisfies these equations, we need to find the smallest N, so
-we should use the >= inequality to find the smallest:
-
- N = ceiling((2Mdy - dx + B) / 2dx)
- = floor((2Mdy - dx + B + 2dx - 1) / 2dx)
- = floor((2Mdy + dx + B - 1) / 2dx)
-
-Case 2b: X major, starting X coordinate moved to M steps from end
-
-Same derivations as Case 2, but we want the smallest number of Y
-steps, so we want the highest N, so we use the < inequality:
-
- N = ceiling((2Mdy + dx + B) / 2dx) - 1
- = floor((2Mdy + dx + B + 2dx - 1) / 2dx) - 1
- = floor((2Mdy + dx + B + 2dx - 1 - 2dx) / 2dx)
- = floor((2Mdy + dx + B - 1) / 2dx)
-
-Case 3: Y major, starting X coordinate moved by M steps
-
- -2dy <= 2Ndx - 2Mdy - dy - B < 0
- 2Ndx >= 2Mdy + dy + B - 2dy 2Ndx < 2Mdy + dy + B
- 2Ndx >= 2Mdy - dy + B N < (2Mdy + dy + B) / 2dx
- N >= (2Mdy - dy + B) / 2dx
-
-Since we are trying to find the smallest N that satisfies these
-equations, we should use the >= inequality to find the smallest:
-
- N = ceiling((2Mdy - dy + B) / 2dx)
- = floor((2Mdy - dy + B + 2dx - 1) / 2dx)
- = floor((2Mdy - dy + B - 1) / 2dx) + 1
-
-Case 3b: Y major, ending X coordinate moved to M steps
-
-Same derivations as Case 3, but we want the largest N that satisfies
-the equations, so we use the < inequality:
-
- N = ceiling((2Mdy + dy + B) / 2dx) - 1
- = floor((2Mdy + dy + B + 2dx - 1) / 2dx) - 1
- = floor((2Mdy + dy + B + 2dx - 1 - 2dx) / 2dx)
- = floor((2Mdy + dy + B - 1) / 2dx)
-
-Case 4: Y major, ending X coordinate moved by M steps
-
- -2dy <= 2(dy - N)dx - 2(dx - M)dy - dy - B < 0
- -2dy <= 2dxdy - 2Ndx - 2dxdy + 2Mdy - dy - B < 0
- -2dy <= 2Mdy - 2Ndx - dy - B < 0
- 2Ndx <= 2Mdy - dy - B + 2dy 2Ndx > 2Mdy - dy - B
- 2Ndx <= 2Mdy + dy - B N > (2Mdy - dy - B) / 2dx
- N <= (2Mdy + dy - B) / 2dx
-
-Since we are trying to find the highest number of Y steps that
-satisfies these equations, we need to find the smallest N, so
-we should use the > inequality to find the smallest:
-
- N = floor((2Mdy - dy - B) / 2dx) + 1
-
-Case 4b: Y major, starting X coordinate moved to M steps from end
-
-Same analysis as Case 4, but we want the smallest number of Y steps
-which means the largest N, so we use the <= inequality:
-
- N = floor((2Mdy + dy - B) / 2dx)
-
-Now let's try the Y coordinates, we have the same 4 cases.
-
-Case 5: X major, starting Y coordinate moved by N steps
-
- -2dx <= 2Mdy - 2Ndx - dx - B < 0
- 2Mdy >= 2Ndx + dx + B - 2dx 2Mdy < 2Ndx + dx + B
- 2Mdy >= 2Ndx - dx + B M < (2Ndx + dx + B) / 2dy
- M >= (2Ndx - dx + B) / 2dy
-
-Since we are trying to find the smallest M, we use the >= inequality:
-
- M = ceiling((2Ndx - dx + B) / 2dy)
- = floor((2Ndx - dx + B + 2dy - 1) / 2dy)
- = floor((2Ndx - dx + B - 1) / 2dy) + 1
-
-Case 5b: X major, ending Y coordinate moved to N steps
-
-Same derivations as Case 5, but we want the largest M that satisfies
-the equations, so we use the < inequality:
-
- M = ceiling((2Ndx + dx + B) / 2dy) - 1
- = floor((2Ndx + dx + B + 2dy - 1) / 2dy) - 1
- = floor((2Ndx + dx + B + 2dy - 1 - 2dy) / 2dy)
- = floor((2Ndx + dx + B - 1) / 2dy)
-
-Case 6: X major, ending Y coordinate moved by N steps
-
- -2dx <= 2(dx - M)dy - 2(dy - N)dx - dx - B < 0
- -2dx <= 2dxdy - 2Mdy - 2dxdy + 2Ndx - dx - B < 0
- -2dx <= 2Ndx - 2Mdy - dx - B < 0
- 2Mdy <= 2Ndx - dx - B + 2dx 2Mdy > 2Ndx - dx - B
- 2Mdy <= 2Ndx + dx - B M > (2Ndx - dx - B) / 2dy
- M <= (2Ndx + dx - B) / 2dy
-
-Largest # of X steps means smallest M, so use the > inequality:
-
- M = floor((2Ndx - dx - B) / 2dy) + 1
-
-Case 6b: X major, starting Y coordinate moved to N steps from end
-
-Same derivations as Case 6, but we want the smallest # of X steps
-which means the largest M, so use the <= inequality:
-
- M = floor((2Ndx + dx - B) / 2dy)
-
-Case 7: Y major, starting Y coordinate moved by N steps
-
- -2dy <= 2Ndx - 2Mdy - dy - B < 0
- 2Mdy <= 2Ndx - dy - B + 2dy 2Mdy > 2Ndx - dy - B
- 2Mdy <= 2Ndx + dy - B M > (2Ndx - dy - B) / 2dy
- M <= (2Ndx + dy - B) / 2dy
-
-To find the smallest M, use the > inequality:
-
- M = floor((2Ndx - dy - B) / 2dy) + 1
- = floor((2Ndx - dy - B + 2dy) / 2dy)
- = floor((2Ndx + dy - B) / 2dy)
-
-Case 7b: Y major, ending Y coordinate moved to N steps
-
-Same derivations as Case 7, but we want the largest M that satisfies
-the equations, so use the <= inequality:
-
- M = floor((2Ndx + dy - B) / 2dy)
-
-Case 8: Y major, ending Y coordinate moved by N steps
-
- -2dy <= 2(dy - N)dx - 2(dx - M)dy - dy - B < 0
- -2dy <= 2dxdy - 2Ndx - 2dxdy + 2Mdy - dy - B < 0
- -2dy <= 2Mdy - 2Ndx - dy - B < 0
- 2Mdy >= 2Ndx + dy + B - 2dy 2Mdy < 2Ndx + dy + B
- 2Mdy >= 2Ndx - dy + B M < (2Ndx + dy + B) / 2dy
- M >= (2Ndx - dy + B) / 2dy
-
-To find the highest X steps, find the smallest M, use the >= inequality:
-
- M = ceiling((2Ndx - dy + B) / 2dy)
- = floor((2Ndx - dy + B + 2dy - 1) / 2dy)
- = floor((2Ndx + dy + B - 1) / 2dy)
-
-Case 8b: Y major, starting Y coordinate moved to N steps from the end
-
-Same derivations as Case 8, but we want to find the smallest # of X
-steps which means the largest M, so we use the < inequality:
-
- M = ceiling((2Ndx + dy + B) / 2dy) - 1
- = floor((2Ndx + dy + B + 2dy - 1) / 2dy) - 1
- = floor((2Ndx + dy + B + 2dy - 1 - 2dy) / 2dy)
- = floor((2Ndx + dy + B - 1) / 2dy)
-
-So, our equations are:
-
- 1: X major move x1 to x1+M floor((2Mdy + dx - B) / 2dx)
- 1b: X major move x2 to x1+M floor((2Mdy + dx - B) / 2dx)
- 2: X major move x2 to x2-M floor((2Mdy + dx + B - 1) / 2dx)
- 2b: X major move x1 to x2-M floor((2Mdy + dx + B - 1) / 2dx)
-
- 3: Y major move x1 to x1+M floor((2Mdy - dy + B - 1) / 2dx) + 1
- 3b: Y major move x2 to x1+M floor((2Mdy + dy + B - 1) / 2dx)
- 4: Y major move x2 to x2-M floor((2Mdy - dy - B) / 2dx) + 1
- 4b: Y major move x1 to x2-M floor((2Mdy + dy - B) / 2dx)
-
- 5: X major move y1 to y1+N floor((2Ndx - dx + B - 1) / 2dy) + 1
- 5b: X major move y2 to y1+N floor((2Ndx + dx + B - 1) / 2dy)
- 6: X major move y2 to y2-N floor((2Ndx - dx - B) / 2dy) + 1
- 6b: X major move y1 to y2-N floor((2Ndx + dx - B) / 2dy)
-
- 7: Y major move y1 to y1+N floor((2Ndx + dy - B) / 2dy)
- 7b: Y major move y2 to y1+N floor((2Ndx + dy - B) / 2dy)
- 8: Y major move y2 to y2-N floor((2Ndx + dy + B - 1) / 2dy)
- 8b: Y major move y1 to y2-N floor((2Ndx + dy + B - 1) / 2dy)
-
-We have the following constraints on all of the above terms:
-
- 0 < M,N <= 2^15 2^15 can be imposed by miZeroClipLine
- 0 <= dx/dy <= 2^16 - 1
- 0 <= B <= 1
-
-The floor in all of the above equations can be accomplished with a
-simple C divide operation provided that both numerator and denominator
-are positive.
-
-Since dx,dy >= 0 and since moving an X coordinate implies that dx != 0
-and moving a Y coordinate implies dy != 0, we know that the denominators
-are all > 0.
-
-For all lines, (-B) and (B-1) are both either 0 or -1, depending on the
-bias. Thus, we have to show that the 2MNdxy +/- dxy terms are all >= 1
-or > 0 to prove that the numerators are positive (or zero).
-
-For X Major lines we know that dx > 0 and since 2Mdy is >= 0 due to the
-constraints, the first four equations all have numerators >= 0.
-
-For the second four equations, M > 0, so 2Mdy >= 2dy so (2Mdy - dy) >= dy
-So (2Mdy - dy) > 0, since they are Y major lines. Also, (2Mdy + dy) >= 3dy
-or (2Mdy + dy) > 0. So all of their numerators are >= 0.
-
-For the third set of four equations, N > 0, so 2Ndx >= 2dx so (2Ndx - dx)
->= dx > 0. Similarly (2Ndx + dx) >= 3dx > 0. So all numerators >= 0.
-
-For the fourth set of equations, dy > 0 and 2Ndx >= 0, so all numerators
-are > 0.
-
-To consider overflow, consider the case of 2 * M,N * dx,dy + dx,dy. This
-is bounded <= 2 * 2^15 * (2^16 - 1) + (2^16 - 1)
- <= 2^16 * (2^16 - 1) + (2^16 - 1)
- <= 2^32 - 2^16 + 2^16 - 1
- <= 2^32 - 1
-Since the (-B) and (B-1) terms are all 0 or -1, the maximum value of
-the numerator is therefore (2^32 - 1), which does not overflow an unsigned
-32 bit variable.
-
-*/
-
-/* Bit codes for the terms of the 16 clipping equations defined below. */
-
-#define T_2NDX (1 << 0)
-#define T_2MDY (0) /* implicit term */
-#define T_DXNOTY (1 << 1)
-#define T_DYNOTX (0) /* implicit term */
-#define T_SUBDXORY (1 << 2)
-#define T_ADDDX (T_DXNOTY) /* composite term */
-#define T_SUBDX (T_DXNOTY | T_SUBDXORY) /* composite term */
-#define T_ADDDY (T_DYNOTX) /* composite term */
-#define T_SUBDY (T_DYNOTX | T_SUBDXORY) /* composite term */
-#define T_BIASSUBONE (1 << 3)
-#define T_SUBBIAS (0) /* implicit term */
-#define T_DIV2DX (1 << 4)
-#define T_DIV2DY (0) /* implicit term */
-#define T_ADDONE (1 << 5)
-
-/* Bit masks defining the 16 equations used in miZeroClipLine. */
-
-#define EQN1 (T_2MDY | T_ADDDX | T_SUBBIAS | T_DIV2DX)
-#define EQN1B (T_2MDY | T_ADDDX | T_SUBBIAS | T_DIV2DX)
-#define EQN2 (T_2MDY | T_ADDDX | T_BIASSUBONE | T_DIV2DX)
-#define EQN2B (T_2MDY | T_ADDDX | T_BIASSUBONE | T_DIV2DX)
-
-#define EQN3 (T_2MDY | T_SUBDY | T_BIASSUBONE | T_DIV2DX | T_ADDONE)
-#define EQN3B (T_2MDY | T_ADDDY | T_BIASSUBONE | T_DIV2DX)
-#define EQN4 (T_2MDY | T_SUBDY | T_SUBBIAS | T_DIV2DX | T_ADDONE)
-#define EQN4B (T_2MDY | T_ADDDY | T_SUBBIAS | T_DIV2DX)
-
-#define EQN5 (T_2NDX | T_SUBDX | T_BIASSUBONE | T_DIV2DY | T_ADDONE)
-#define EQN5B (T_2NDX | T_ADDDX | T_BIASSUBONE | T_DIV2DY)
-#define EQN6 (T_2NDX | T_SUBDX | T_SUBBIAS | T_DIV2DY | T_ADDONE)
-#define EQN6B (T_2NDX | T_ADDDX | T_SUBBIAS | T_DIV2DY)
-
-#define EQN7 (T_2NDX | T_ADDDY | T_SUBBIAS | T_DIV2DY)
-#define EQN7B (T_2NDX | T_ADDDY | T_SUBBIAS | T_DIV2DY)
-#define EQN8 (T_2NDX | T_ADDDY | T_BIASSUBONE | T_DIV2DY)
-#define EQN8B (T_2NDX | T_ADDDY | T_BIASSUBONE | T_DIV2DY)
-
-/* miZeroClipLine
- *
- * returns: 1 for partially clipped line
- * -1 for completely clipped line
- *
- */
-static int
-miZeroClipLine (int xmin, int ymin, int xmax, int ymax,
- int *new_x1, int *new_y1, int *new_x2, int *new_y2,
- unsigned int adx, unsigned int ady,
- int *pt1_clipped, int *pt2_clipped, int octant, unsigned int bias, int oc1, int oc2)
-{
- int swapped = 0;
- int clipDone = 0;
- CARD32 utmp = 0;
- int clip1, clip2;
- int x1, y1, x2, y2;
- int x1_orig, y1_orig, x2_orig, y2_orig;
- int xmajor;
- int negslope = 0, anchorval = 0;
- unsigned int eqn = 0;
-
- x1 = x1_orig = *new_x1;
- y1 = y1_orig = *new_y1;
- x2 = x2_orig = *new_x2;
- y2 = y2_orig = *new_y2;
-
- clip1 = 0;
- clip2 = 0;
-
- xmajor = IsXMajorOctant (octant);
- bias = ((bias >> octant) & 1);
-
- while (1) {
- if ((oc1 & oc2) != 0) { /* trivial reject */
- clipDone = -1;
- clip1 = oc1;
- clip2 = oc2;
- break;
- } else if ((oc1 | oc2) == 0) { /* trivial accept */
- clipDone = 1;
- if (swapped) {
- SWAPINT_PAIR (x1, y1, x2, y2);
- SWAPINT (clip1, clip2);
- }
- break;
- } else { /* have to clip */
-
- /* only clip one point at a time */
- if (oc1 == 0) {
- SWAPINT_PAIR (x1, y1, x2, y2);
- SWAPINT_PAIR (x1_orig, y1_orig, x2_orig, y2_orig);
- SWAPINT (oc1, oc2);
- SWAPINT (clip1, clip2);
- swapped = !swapped;
- }
-
- clip1 |= oc1;
- if (oc1 & OUT_LEFT) {
- negslope = IsYDecreasingOctant (octant);
- utmp = xmin - x1_orig;
- if (utmp <= 32767) { /* clip based on near endpt */
- if (xmajor)
- eqn = (swapped) ? EQN2 : EQN1;
- else
- eqn = (swapped) ? EQN4 : EQN3;
- anchorval = y1_orig;
- } else { /* clip based on far endpt */
-
- utmp = x2_orig - xmin;
- if (xmajor)
- eqn = (swapped) ? EQN1B : EQN2B;
- else
- eqn = (swapped) ? EQN3B : EQN4B;
- anchorval = y2_orig;
- negslope = !negslope;
- }
- x1 = xmin;
- } else if (oc1 & OUT_ABOVE) {
- negslope = IsXDecreasingOctant (octant);
- utmp = ymin - y1_orig;
- if (utmp <= 32767) { /* clip based on near endpt */
- if (xmajor)
- eqn = (swapped) ? EQN6 : EQN5;
- else
- eqn = (swapped) ? EQN8 : EQN7;
- anchorval = x1_orig;
- } else { /* clip based on far endpt */
-
- utmp = y2_orig - ymin;
- if (xmajor)
- eqn = (swapped) ? EQN5B : EQN6B;
- else
- eqn = (swapped) ? EQN7B : EQN8B;
- anchorval = x2_orig;
- negslope = !negslope;
- }
- y1 = ymin;
- } else if (oc1 & OUT_RIGHT) {
- negslope = IsYDecreasingOctant (octant);
- utmp = x1_orig - xmax;
- if (utmp <= 32767) { /* clip based on near endpt */
- if (xmajor)
- eqn = (swapped) ? EQN2 : EQN1;
- else
- eqn = (swapped) ? EQN4 : EQN3;
- anchorval = y1_orig;
- } else { /* clip based on far endpt */
-
- /*
- * Technically since the equations can handle
- * utmp == 32768, this overflow code isn't
- * needed since X11 protocol can't generate
- * a line which goes more than 32768 pixels
- * to the right of a clip rectangle.
- */
- utmp = xmax - x2_orig;
- if (xmajor)
- eqn = (swapped) ? EQN1B : EQN2B;
- else
- eqn = (swapped) ? EQN3B : EQN4B;
- anchorval = y2_orig;
- negslope = !negslope;
- }
- x1 = xmax;
- } else if (oc1 & OUT_BELOW) {
- negslope = IsXDecreasingOctant (octant);
- utmp = y1_orig - ymax;
- if (utmp <= 32767) { /* clip based on near endpt */
- if (xmajor)
- eqn = (swapped) ? EQN6 : EQN5;
- else
- eqn = (swapped) ? EQN8 : EQN7;
- anchorval = x1_orig;
- } else { /* clip based on far endpt */
-
- /*
- * Technically since the equations can handle
- * utmp == 32768, this overflow code isn't
- * needed since X11 protocol can't generate
- * a line which goes more than 32768 pixels
- * below the bottom of a clip rectangle.
- */
- utmp = ymax - y2_orig;
- if (xmajor)
- eqn = (swapped) ? EQN5B : EQN6B;
- else
- eqn = (swapped) ? EQN7B : EQN8B;
- anchorval = x2_orig;
- negslope = !negslope;
- }
- y1 = ymax;
- }
-
- if (swapped)
- negslope = !negslope;
-
- utmp <<= 1; /* utmp = 2N or 2M */
- if (eqn & T_2NDX)
- utmp = (utmp * adx);
- else /* (eqn & T_2MDY) */
- utmp = (utmp * ady);
- if (eqn & T_DXNOTY)
- if (eqn & T_SUBDXORY)
- utmp -= adx;
- else
- utmp += adx;
- else /* (eqn & T_DYNOTX) */ if (eqn & T_SUBDXORY)
- utmp -= ady;
- else
- utmp += ady;
- if (eqn & T_BIASSUBONE)
- utmp += bias - 1;
- else /* (eqn & T_SUBBIAS) */
- utmp -= bias;
- if (eqn & T_DIV2DX)
- utmp /= (adx << 1);
- else /* (eqn & T_DIV2DY) */
- utmp /= (ady << 1);
- if (eqn & T_ADDONE)
- utmp++;
-
- if (negslope)
- utmp = (uint32_t)(-(int32_t)utmp);
-
- if (eqn & T_2NDX) /* We are calculating X steps */
- x1 = anchorval + utmp;
- else /* else, Y steps */
- y1 = anchorval + utmp;
-
- oc1 = 0;
- MIOUTCODES (oc1, x1, y1, xmin, ymin, xmax, ymax);
- }
- }
-
- *new_x1 = x1;
- *new_y1 = y1;
- *new_x2 = x2;
- *new_y2 = y2;
-
- *pt1_clipped = clip1;
- *pt2_clipped = clip2;
-
- return clipDone;
-}
-
-/* Draw lineSolid, fillStyle-independent zero width lines.
- *
- * Must keep X and Y coordinates in "ints" at least until after they're
- * translated and clipped to accomodate CoordModePrevious lines with very
- * large coordinates.
- *
- * Draws the same pixels regardless of sign(dx) or sign(dy).
- *
- * Ken Whaley
- *
- */
-
-#define MI_OUTPUT_POINT(xx, yy)\
-{\
- if ( !new_span && yy == current_y)\
- {\
- if (xx < spans->x)\
- spans->x = xx;\
- ++*widths;\
- }\
- else\
- {\
- ++Nspans;\
- ++spans;\
- ++widths;\
- spans->x = xx;\
- spans->y = yy;\
- *widths = 1;\
- current_y = yy;\
- new_span = FALSE;\
- }\
-}
-
-void
-miZeroLine (GCPtr pGC, int mode, /* Origin or Previous */
- int npt, /* number of points */
- DDXPointPtr pptInit)
-{
- int Nspans, current_y = 0;
- DDXPointPtr ppt;
- DDXPointPtr pspanInit, spans;
- int *pwidthInit, *widths, list_len;
- int xleft, ytop, xright, ybottom;
- int new_x1, new_y1, new_x2, new_y2;
- int x = 0, y = 0, x1, y1, x2, y2, xstart, ystart;
- int oc1, oc2;
- int result;
- int pt1_clipped, pt2_clipped = 0;
- Boolean new_span;
- int signdx, signdy;
- int clipdx, clipdy;
- int width, height;
- int adx, ady;
- int octant;
- unsigned int bias = miGetZeroLineBias (screen);
- int e, e1, e2, e3; /* Bresenham error terms */
- int length; /* length of lines == # of pixels on major axis */
-
- xleft = 0;
- ytop = 0;
- xright = pGC->width - 1;
- ybottom = pGC->height - 1;
-
- /* it doesn't matter whether we're in drawable or screen coordinates,
- * FillSpans simply cannot take starting coordinates outside of the
- * range of a DDXPointRec component.
- */
- if (xright > MAX_COORDINATE)
- xright = MAX_COORDINATE;
- if (ybottom > MAX_COORDINATE)
- ybottom = MAX_COORDINATE;
-
- /* since we're clipping to the drawable's boundaries & coordinate
- * space boundaries, we're guaranteed that the larger of width/height
- * is the longest span we'll need to output
- */
- width = xright - xleft + 1;
- height = ybottom - ytop + 1;
- list_len = (height >= width) ? height : width;
- pspanInit = (DDXPointRec *)xalloc (list_len * sizeof (DDXPointRec));
- pwidthInit = (int *)xalloc (list_len * sizeof (int));
- if (!pspanInit || !pwidthInit)
- goto out;
-
- Nspans = 0;
- new_span = TRUE;
- spans = pspanInit - 1;
- widths = pwidthInit - 1;
- ppt = pptInit;
-
- xstart = ppt->x;
- ystart = ppt->y;
-
- /* x2, y2, oc2 copied to x1, y1, oc1 at top of loop to simplify
- * iteration logic
- */
- x2 = xstart;
- y2 = ystart;
- oc2 = 0;
- MIOUTCODES (oc2, x2, y2, xleft, ytop, xright, ybottom);
-
- while (--npt > 0) {
- if (Nspans > 0)
- (*pGC->ops->FillSpans) (pGC, Nspans, pspanInit, pwidthInit, FALSE, TRUE);
- Nspans = 0;
- new_span = TRUE;
- spans = pspanInit - 1;
- widths = pwidthInit - 1;
-
- x1 = x2;
- y1 = y2;
- oc1 = oc2;
- ++ppt;
-
- x2 = ppt->x;
- y2 = ppt->y;
- if (mode == CoordModePrevious) {
- x2 += x1;
- y2 += y1;
- }
-
- oc2 = 0;
- MIOUTCODES (oc2, x2, y2, xleft, ytop, xright, ybottom);
-
- CalcLineDeltas (x1, y1, x2, y2, adx, ady, signdx, signdy, 1, 1, octant);
-
- if (adx > ady) {
- e1 = ady << 1;
- e2 = e1 - (adx << 1);
- e = e1 - adx;
- length = adx; /* don't draw endpoint in main loop */
-
- FIXUP_ERROR (e, octant, bias);
-
- new_x1 = x1;
- new_y1 = y1;
- new_x2 = x2;
- new_y2 = y2;
- pt1_clipped = 0;
- pt2_clipped = 0;
-
- if ((oc1 | oc2) != 0) {
- result = miZeroClipLine (xleft, ytop, xright, ybottom,
- &new_x1, &new_y1, &new_x2, &new_y2,
- adx, ady,
- &pt1_clipped, &pt2_clipped, octant, bias, oc1, oc2);
- if (result == -1)
- continue;
-
- length = abs (new_x2 - new_x1);
-
- /* if we've clipped the endpoint, always draw the full length
- * of the segment, because then the capstyle doesn't matter
- */
- if (pt2_clipped)
- length++;
-
- if (pt1_clipped) {
- /* must calculate new error terms */
- clipdx = abs (new_x1 - x1);
- clipdy = abs (new_y1 - y1);
- e += (clipdy * e2) + ((clipdx - clipdy) * e1);
- }
- }
-
- /* draw the segment */
-
- x = new_x1;
- y = new_y1;
-
- e3 = e2 - e1;
- e = e - e1;
-
- while (length--) {
- MI_OUTPUT_POINT (x, y);
- e += e1;
- if (e >= 0) {
- y += signdy;
- e += e3;
- }
- x += signdx;
- }
- } else { /* Y major line */
-
- e1 = adx << 1;
- e2 = e1 - (ady << 1);
- e = e1 - ady;
- length = ady; /* don't draw endpoint in main loop */
-
- SetYMajorOctant (octant);
- FIXUP_ERROR (e, octant, bias);
-
- new_x1 = x1;
- new_y1 = y1;
- new_x2 = x2;
- new_y2 = y2;
- pt1_clipped = 0;
- pt2_clipped = 0;
-
- if ((oc1 | oc2) != 0) {
- result = miZeroClipLine (xleft, ytop, xright, ybottom,
- &new_x1, &new_y1, &new_x2, &new_y2,
- adx, ady,
- &pt1_clipped, &pt2_clipped, octant, bias, oc1, oc2);
- if (result == -1)
- continue;
-
- length = abs (new_y2 - new_y1);
-
- /* if we've clipped the endpoint, always draw the full length
- * of the segment, because then the capstyle doesn't matter
- */
- if (pt2_clipped)
- length++;
-
- if (pt1_clipped) {
- /* must calculate new error terms */
- clipdx = abs (new_x1 - x1);
- clipdy = abs (new_y1 - y1);
- e += (clipdx * e2) + ((clipdy - clipdx) * e1);
- }
- }
-
- /* draw the segment */
-
- x = new_x1;
- y = new_y1;
-
- e3 = e2 - e1;
- e = e - e1;
-
- while (length--) {
- MI_OUTPUT_POINT (x, y);
- e += e1;
- if (e >= 0) {
- x += signdx;
- e += e3;
- }
- y += signdy;
- }
- }
- }
-
- /* only do the capnotlast check on the last segment
- * and only if the endpoint wasn't clipped. And then, if the last
- * point is the same as the first point, do not draw it, unless the
- * line is degenerate
- */
- if ((!pt2_clipped) && (pGC->capStyle != CapNotLast) &&
- (((xstart != x2) || (ystart != y2)) || (ppt == pptInit + 1))) {
- MI_OUTPUT_POINT (x, y);
- }
-
- if (Nspans > 0)
- (*pGC->ops->FillSpans) (pGC, Nspans, pspanInit, pwidthInit, FALSE, TRUE);
-
-out:
- xfree (pwidthInit);
- xfree (pspanInit);
-}
-
-void
-miZeroDashLine (GCPtr pgc, int mode, int nptInit, /* number of points in polyline */
- DDXPointRec * pptInit /* points in the polyline */
- )
-{
- /* XXX kludge until real zero-width dash code is written */
- pgc->lineWidth = 1;
- miWideDash (pgc, mode, nptInit, pptInit);
- pgc->lineWidth = 0;
-}
-
-static void miLineArc (GCPtr pGC,
- Boolean foreground, SpanDataPtr spanData,
- LineFacePtr leftFace,
- LineFacePtr rightFace, double xorg, double yorg, Boolean isInt);
-
-
-/*
- * spans-based polygon filler
- */
-
-static void
-miFillPolyHelper (GCPtr pGC, Boolean foreground,
- SpanDataPtr spanData, int y, int overall_height,
- PolyEdgePtr left, PolyEdgePtr right, int left_count, int right_count)
-{
- int left_x = 0, left_e = 0;
- int left_stepx = 0;
- int left_signdx = 0;
- int left_dy = 0, left_dx = 0;
-
- int right_x = 0, right_e = 0;
- int right_stepx = 0;
- int right_signdx = 0;
- int right_dy = 0, right_dx = 0;
-
- int height = 0;
- int left_height = 0, right_height = 0;
-
- DDXPointPtr ppt;
- DDXPointPtr pptInit = NULL;
- int *pwidth;
- int *pwidthInit = NULL;
- int xorg;
- Spans spanRec;
-
- left_height = 0;
- right_height = 0;
-
- if (!spanData) {
- pptInit = (DDXPointRec *)xalloc (overall_height * sizeof (*ppt));
- if (!pptInit)
- return;
- pwidthInit = (int *)xalloc (overall_height * sizeof (*pwidth));
- if (!pwidthInit) {
- xfree (pptInit);
- return;
- }
- ppt = pptInit;
- pwidth = pwidthInit;
- } else {
- spanRec.points = (DDXPointRec *)xalloc (overall_height * sizeof (*ppt));
- if (!spanRec.points)
- return;
- spanRec.widths = (int *)xalloc (overall_height * sizeof (int));
- if (!spanRec.widths) {
- xfree (spanRec.points);
- return;
- }
- ppt = spanRec.points;
- pwidth = spanRec.widths;
- }
-
- xorg = 0;
- while ((left_count || left_height) && (right_count || right_height)) {
- MIPOLYRELOADLEFT MIPOLYRELOADRIGHT height = left_height;
- if (height > right_height)
- height = right_height;
-
- left_height -= height;
- right_height -= height;
-
- while (--height >= 0) {
- if (right_x >= left_x) {
- ppt->y = y;
- ppt->x = left_x + xorg;
- ppt++;
- *pwidth++ = right_x - left_x + 1;
- }
- y++;
-
- MIPOLYSTEPLEFT MIPOLYSTEPRIGHT}
- }
- if (!spanData) {
- (*pGC->ops->FillSpans) (pGC, ppt - pptInit, pptInit, pwidthInit, TRUE, foreground);
- xfree (pwidthInit);
- xfree (pptInit);
- } else {
- spanRec.count = ppt - spanRec.points;
- AppendSpanGroup (pGC, foreground, &spanRec, spanData)
- }
-}
-
-static void
-miFillRectPolyHelper (GCPtr pGC, Boolean foreground, SpanDataPtr spanData, int x, int y, int w, int h)
-{
- DDXPointPtr ppt;
- int *pwidth;
- Spans spanRec;
- xRectangle rect;
-
- if (!spanData) {
- rect.x = x;
- rect.y = y;
- rect.width = w;
- rect.height = h;
- (*pGC->ops->FillRects) (pGC, 1, &rect, foreground);
- } else {
- spanRec.points = (DDXPointRec *)xalloc (h * sizeof (*ppt));
- if (!spanRec.points)
- return;
- spanRec.widths = (int *)xalloc (h * sizeof (int));
- if (!spanRec.widths) {
- xfree (spanRec.points);
- return;
- }
- ppt = spanRec.points;
- pwidth = spanRec.widths;
-
- while (h--) {
- ppt->x = x;
- ppt->y = y;
- ppt++;
- *pwidth++ = w;
- y++;
- }
- spanRec.count = ppt - spanRec.points;
- AppendSpanGroup (pGC, foreground, &spanRec, spanData)
- }
-}
-
-static int
-miPolyBuildEdge (double x0, double y0, double k, /* x0 * dy - y0 * dx */
- int dx, int dy, int xi, int yi, int left, PolyEdgePtr edge)
-{
- int x, y, e;
- int xady;
-
- if (dy < 0) {
- dy = -dy;
- dx = -dx;
- k = -k;
- }
-#ifdef NOTDEF
- {
- double realk, kerror;
- realk = x0 * dy - y0 * dx;
- kerror = Fabs (realk - k);
- if (kerror > .1)
- printf ("realk: %g k: %g\n", realk, k);
- }
-#endif
- y = ICEIL (y0);
- xady = ICEIL (k) + y * dx;
-
- if (xady <= 0)
- x = -(-xady / dy) - 1;
- else
- x = (xady - 1) / dy;
-
- e = xady - x * dy;
-
- if (dx >= 0) {
- edge->signdx = 1;
- edge->stepx = dx / dy;
- edge->dx = dx % dy;
- } else {
- edge->signdx = -1;
- edge->stepx = -(-dx / dy);
- edge->dx = -dx % dy;
- e = dy - e + 1;
- }
- edge->dy = dy;
- edge->x = x + left + xi;
- edge->e = e - dy; /* bias to compare against 0 instead of dy */
- return y + yi;
-}
-
-#define StepAround(v, incr, max) (((v) + (incr) < 0) ? (max - 1) : ((v) + (incr) == max) ? 0 : ((v) + (incr)))
-
-static int
-miPolyBuildPoly (PolyVertexPtr vertices,
- PolySlopePtr slopes,
- int count,
- int xi,
- int yi, PolyEdgePtr left, PolyEdgePtr right, int *pnleft, int *pnright, int *h)
-{
- int top, bottom;
- double miny, maxy;
- int i;
- int j;
- int clockwise;
- int slopeoff;
- int s;
- int nright, nleft;
- int y, lasty = 0, bottomy, topy = 0;
-
- /* find the top of the polygon */
- maxy = miny = vertices[0].y;
- bottom = top = 0;
- for (i = 1; i < count; i++) {
- if (vertices[i].y < miny) {
- top = i;
- miny = vertices[i].y;
- }
- if (vertices[i].y >= maxy) {
- bottom = i;
- maxy = vertices[i].y;
- }
- }
- clockwise = 1;
- slopeoff = 0;
-
- i = top;
- j = StepAround (top, -1, count);
-
- if (slopes[j].dy * slopes[i].dx > slopes[i].dy * slopes[j].dx) {
- clockwise = -1;
- slopeoff = -1;
- }
-
- bottomy = ICEIL (maxy) + yi;
-
- nright = 0;
-
- s = StepAround (top, slopeoff, count);
- i = top;
- while (i != bottom) {
- if (slopes[s].dy != 0) {
- y = miPolyBuildEdge (vertices[i].x, vertices[i].y,
- slopes[s].k,
- slopes[s].dx, slopes[s].dy, xi, yi, 0, &right[nright]);
- if (nright != 0)
- right[nright - 1].height = y - lasty;
- else
- topy = y;
- nright++;
- lasty = y;
- }
-
- i = StepAround (i, clockwise, count);
- s = StepAround (s, clockwise, count);
- }
- if (nright != 0)
- right[nright - 1].height = bottomy - lasty;
-
- if (slopeoff == 0)
- slopeoff = -1;
- else
- slopeoff = 0;
-
- nleft = 0;
- s = StepAround (top, slopeoff, count);
- i = top;
- while (i != bottom) {
- if (slopes[s].dy != 0) {
- y = miPolyBuildEdge (vertices[i].x, vertices[i].y,
- slopes[s].k, slopes[s].dx, slopes[s].dy, xi, yi, 1, &left[nleft]);
-
- if (nleft != 0)
- left[nleft - 1].height = y - lasty;
- nleft++;
- lasty = y;
- }
- i = StepAround (i, -clockwise, count);
- s = StepAround (s, -clockwise, count);
- }
- if (nleft != 0)
- left[nleft - 1].height = bottomy - lasty;
- *pnleft = nleft;
- *pnright = nright;
- *h = bottomy - topy;
- return topy;
-}
-
-static void
-miLineOnePoint (GCPtr pGC, Boolean foreground, SpanDataPtr spanData, int x, int y)
-{
- DDXPointRec pt;
- int wid;
-
- wid = 1;
- pt.x = x;
- pt.y = y;
- (*pGC->ops->FillSpans) (pGC, 1, &pt, &wid, TRUE, foreground);
-}
-
-static void
-miLineJoin (GCPtr pGC, Boolean foreground, SpanDataPtr spanData, LineFacePtr pLeft, LineFacePtr pRight)
-{
- double mx = 0, my = 0;
- double denom = 0.0;
- PolyVertexRec vertices[4];
- PolySlopeRec slopes[4];
- int edgecount;
- PolyEdgeRec left[4], right[4];
- int nleft, nright;
- int y, height;
- int swapslopes;
- int joinStyle = pGC->joinStyle;
- int lw = pGC->lineWidth;
-
- if (lw == 1 && !spanData) {
- /* See if one of the lines will draw the joining pixel */
- if (pLeft->dx > 0 || (pLeft->dx == 0 && pLeft->dy > 0))
- return;
- if (pRight->dx > 0 || (pRight->dx == 0 && pRight->dy > 0))
- return;
- if (joinStyle != JoinRound) {
- denom = -pLeft->dx * (double) pRight->dy + pRight->dx * (double) pLeft->dy;
- if (denom == 0)
- return; /* no join to draw */
- }
- if (joinStyle != JoinMiter) {
- miLineOnePoint (pGC, foreground, spanData, pLeft->x, pLeft->y);
- return;
- }
- } else {
- if (joinStyle == JoinRound) {
- miLineArc (pGC, foreground, spanData, pLeft, pRight, (double) 0.0, (double) 0.0, TRUE);
- return;
- }
- denom = -pLeft->dx * (double) pRight->dy + pRight->dx * (double) pLeft->dy;
- if (denom == 0.0)
- return; /* no join to draw */
- }
-
- swapslopes = 0;
- if (denom > 0) {
- pLeft->xa = -pLeft->xa;
- pLeft->ya = -pLeft->ya;
- pLeft->dx = -pLeft->dx;
- pLeft->dy = -pLeft->dy;
- } else {
- swapslopes = 1;
- pRight->xa = -pRight->xa;
- pRight->ya = -pRight->ya;
- pRight->dx = -pRight->dx;
- pRight->dy = -pRight->dy;
- }
-
- vertices[0].x = pRight->xa;
- vertices[0].y = pRight->ya;
- slopes[0].dx = -pRight->dy;
- slopes[0].dy = pRight->dx;
- slopes[0].k = 0;
-
- vertices[1].x = 0;
- vertices[1].y = 0;
- slopes[1].dx = pLeft->dy;
- slopes[1].dy = -pLeft->dx;
- slopes[1].k = 0;
-
- vertices[2].x = pLeft->xa;
- vertices[2].y = pLeft->ya;
-
- if (joinStyle == JoinMiter) {
- my = (pLeft->dy * (pRight->xa * pRight->dy - pRight->ya * pRight->dx) -
- pRight->dy * (pLeft->xa * pLeft->dy - pLeft->ya * pLeft->dx)) / denom;
- if (pLeft->dy != 0) {
- mx = pLeft->xa + (my - pLeft->ya) * (double) pLeft->dx / (double) pLeft->dy;
- } else {
- mx = pRight->xa + (my - pRight->ya) * (double) pRight->dx / (double) pRight->dy;
- }
- /* check miter limit */
- if ((mx * mx + my * my) * 4 > SQSECANT * lw * lw)
- joinStyle = JoinBevel;
- }
-
- if (joinStyle == JoinMiter) {
- slopes[2].dx = pLeft->dx;
- slopes[2].dy = pLeft->dy;
- slopes[2].k = pLeft->k;
- if (swapslopes) {
- slopes[2].dx = -slopes[2].dx;
- slopes[2].dy = -slopes[2].dy;
- slopes[2].k = -slopes[2].k;
- }
- vertices[3].x = mx;
- vertices[3].y = my;
- slopes[3].dx = pRight->dx;
- slopes[3].dy = pRight->dy;
- slopes[3].k = pRight->k;
- if (swapslopes) {
- slopes[3].dx = -slopes[3].dx;
- slopes[3].dy = -slopes[3].dy;
- slopes[3].k = -slopes[3].k;
- }
- edgecount = 4;
- } else {
- double scale, dx, dy, adx, ady;
-
- adx = dx = pRight->xa - pLeft->xa;
- ady = dy = pRight->ya - pLeft->ya;
- if (adx < 0)
- adx = -adx;
- if (ady < 0)
- ady = -ady;
- scale = ady;
- if (adx > ady)
- scale = adx;
- slopes[2].dx = (int) ((dx * 65536) / scale);
- slopes[2].dy = (int) ((dy * 65536) / scale);
- slopes[2].k = ((pLeft->xa + pRight->xa) * slopes[2].dy -
- (pLeft->ya + pRight->ya) * slopes[2].dx) / 2.0;
- edgecount = 3;
- }
-
- y = miPolyBuildPoly (vertices, slopes, edgecount, pLeft->x, pLeft->y,
- left, right, &nleft, &nright, &height);
- miFillPolyHelper (pGC, foreground, spanData, y, height, left, right, nleft, nright);
-}
-
-static int
-miLineArcI (GCPtr pGC, int xorg, int yorg, DDXPointPtr points, int *widths)
-{
- DDXPointPtr tpts, bpts;
- int *twids, *bwids;
- int x, y, e, ex, slw;
-
- tpts = points;
- twids = widths;
- slw = pGC->lineWidth;
- if (slw == 1) {
- tpts->x = xorg;
- tpts->y = yorg;
- *twids = 1;
- return 1;
- }
- bpts = tpts + slw;
- bwids = twids + slw;
- y = (slw >> 1) + 1;
- if (slw & 1)
- e = -((y << 2) + 3);
- else
- e = -(y << 3);
- ex = -4;
- x = 0;
- while (y) {
- e += (y << 3) - 4;
- while (e >= 0) {
- x++;
- e += (ex = -((x << 3) + 4));
- }
- y--;
- slw = (x << 1) + 1;
- if ((e == ex) && (slw > 1))
- slw--;
- tpts->x = xorg - x;
- tpts->y = yorg - y;
- tpts++;
- *twids++ = slw;
- if ((y != 0) && ((slw > 1) || (e != ex))) {
- bpts--;
- bpts->x = xorg - x;
- bpts->y = yorg + y;
- *--bwids = slw;
- }
- }
- return (pGC->lineWidth);
-}
-
-#define CLIPSTEPEDGE(edgey,edge,edgeleft) \
- if (ybase == edgey) \
- { \
- if (edgeleft) \
- { \
- if (edge->x > xcl) \
- xcl = edge->x; \
- } \
- else \
- { \
- if (edge->x < xcr) \
- xcr = edge->x; \
- } \
- edgey++; \
- edge->x += edge->stepx; \
- edge->e += edge->dx; \
- if (edge->e > 0) \
- { \
- edge->x += edge->signdx; \
- edge->e -= edge->dy; \
- } \
- }
-
-static int
-miLineArcD (GCPtr pGC,
- double xorg,
- double yorg,
- DDXPointPtr points,
- int *widths,
- PolyEdgePtr edge1,
- int edgey1, Boolean edgeleft1, PolyEdgePtr edge2, int edgey2, Boolean edgeleft2)
-{
- DDXPointPtr pts;
- int *wids;
- double radius, x0, y0, el, er, yk, xlk, xrk, k;
- int xbase, ybase, y, boty, xl, xr, xcl, xcr;
- int ymin, ymax;
- Boolean edge1IsMin, edge2IsMin;
- int ymin1, ymin2;
-
- pts = points;
- wids = widths;
- xbase = (int)floor (xorg);
- x0 = xorg - xbase;
- ybase = ICEIL (yorg);
- y0 = yorg - ybase;
- xlk = x0 + x0 + 1.0;
- xrk = x0 + x0 - 1.0;
- yk = y0 + y0 - 1.0;
- radius = ((double) pGC->lineWidth) / 2.0;
- y = (int)floor (radius - y0 + 1.0);
- ybase -= y;
- ymin = ybase;
- ymax = 65536;
- edge1IsMin = FALSE;
- ymin1 = edgey1;
- if (edge1->dy >= 0) {
- if (!edge1->dy) {
- if (edgeleft1)
- edge1IsMin = TRUE;
- else
- ymax = edgey1;
- edgey1 = 65536;
- } else {
- if ((edge1->signdx < 0) == edgeleft1)
- edge1IsMin = TRUE;
- }
- }
- edge2IsMin = FALSE;
- ymin2 = edgey2;
- if (edge2->dy >= 0) {
- if (!edge2->dy) {
- if (edgeleft2)
- edge2IsMin = TRUE;
- else
- ymax = edgey2;
- edgey2 = 65536;
- } else {
- if ((edge2->signdx < 0) == edgeleft2)
- edge2IsMin = TRUE;
- }
- }
- if (edge1IsMin) {
- ymin = ymin1;
- if (edge2IsMin && ymin1 > ymin2)
- ymin = ymin2;
- } else if (edge2IsMin)
- ymin = ymin2;
- el = radius * radius - ((y + y0) * (y + y0)) - (x0 * x0);
- er = el + xrk;
- xl = 1;
- xr = 0;
- if (x0 < 0.5) {
- xl = 0;
- el -= xlk;
- }
- boty = (y0 < -0.5) ? 1 : 0;
- if (ybase + y - boty > ymax)
- boty = ymax - ybase - y;
- while (y > boty) {
- k = (y << 1) + yk;
- er += k;
- while (er > 0.0) {
- xr++;
- er += xrk - (xr << 1);
- }
- el += k;
- while (el >= 0.0) {
- xl--;
- el += (xl << 1) - xlk;
- }
- y--;
- ybase++;
- if (ybase < ymin)
- continue;
- xcl = xl + xbase;
- xcr = xr + xbase;
- CLIPSTEPEDGE (edgey1, edge1, edgeleft1);
- CLIPSTEPEDGE (edgey2, edge2, edgeleft2);
- if (xcr >= xcl) {
- pts->x = xcl;
- pts->y = ybase;
- pts++;
- *wids++ = xcr - xcl + 1;
- }
- }
- er = xrk - (xr << 1) - er;
- el = (xl << 1) - xlk - el;
- boty = (int)floor (-y0 - radius + 1.0);
- if (ybase + y - boty > ymax)
- boty = ymax - ybase - y;
- while (y > boty) {
- k = (y << 1) + yk;
- er -= k;
- while ((er >= 0.0) && (xr >= 0)) {
- xr--;
- er += xrk - (xr << 1);
- }
- el -= k;
- while ((el > 0.0) && (xl <= 0)) {
- xl++;
- el += (xl << 1) - xlk;
- }
- y--;
- ybase++;
- if (ybase < ymin)
- continue;
- xcl = xl + xbase;
- xcr = xr + xbase;
- CLIPSTEPEDGE (edgey1, edge1, edgeleft1);
- CLIPSTEPEDGE (edgey2, edge2, edgeleft2);
- if (xcr >= xcl) {
- pts->x = xcl;
- pts->y = ybase;
- pts++;
- *wids++ = xcr - xcl + 1;
- }
- }
- return (pts - points);
-}
-
-static int
-miRoundJoinFace (LineFacePtr face, PolyEdgePtr edge, Boolean * leftEdge)
-{
- int y;
- int dx, dy;
- double xa, ya;
- Boolean left;
-
- dx = -face->dy;
- dy = face->dx;
- xa = face->xa;
- ya = face->ya;
- left = 1;
- if (ya > 0) {
- ya = 0.0;
- xa = 0.0;
- }
- if (dy < 0 || (dy == 0 && dx > 0)) {
- dx = -dx;
- dy = -dy;
- left = !left;
- }
- if (dx == 0 && dy == 0)
- dy = 1;
- if (dy == 0) {
- y = ICEIL (face->ya) + face->y;
- edge->x = -32767;
- edge->stepx = 0;
- edge->signdx = 0;
- edge->e = -1;
- edge->dy = 0;
- edge->dx = 0;
- edge->height = 0;
- } else {
- y = miPolyBuildEdge (xa, ya, 0.0, dx, dy, face->x, face->y, !left, edge);
- edge->height = 32767;
- }
- *leftEdge = !left;
- return y;
-}
-
-static void
-miRoundJoinClip (LineFacePtr pLeft, LineFacePtr pRight,
- PolyEdgePtr edge1, PolyEdgePtr edge2, int *y1, int *y2, Boolean * left1, Boolean * left2)
-{
- double denom;
-
- denom = -pLeft->dx * (double) pRight->dy + pRight->dx * (double) pLeft->dy;
-
- if (denom >= 0) {
- pLeft->xa = -pLeft->xa;
- pLeft->ya = -pLeft->ya;
- } else {
- pRight->xa = -pRight->xa;
- pRight->ya = -pRight->ya;
- }
- *y1 = miRoundJoinFace (pLeft, edge1, left1);
- *y2 = miRoundJoinFace (pRight, edge2, left2);
-}
-
-static int
-miRoundCapClip (LineFacePtr face, Boolean isInt, PolyEdgePtr edge, Boolean * leftEdge)
-{
- int y;
- int dx, dy;
- double xa, ya, k;
- Boolean left;
-
- dx = -face->dy;
- dy = face->dx;
- xa = face->xa;
- ya = face->ya;
- k = 0.0;
- if (!isInt)
- k = face->k;
- left = 1;
- if (dy < 0 || (dy == 0 && dx > 0)) {
- dx = -dx;
- dy = -dy;
- xa = -xa;
- ya = -ya;
- left = !left;
- }
- if (dx == 0 && dy == 0)
- dy = 1;
- if (dy == 0) {
- y = ICEIL (face->ya) + face->y;
- edge->x = -32767;
- edge->stepx = 0;
- edge->signdx = 0;
- edge->e = -1;
- edge->dy = 0;
- edge->dx = 0;
- edge->height = 0;
- } else {
- y = miPolyBuildEdge (xa, ya, k, dx, dy, face->x, face->y, !left, edge);
- edge->height = 32767;
- }
- *leftEdge = !left;
- return y;
-}
-
-static void
-miLineArc (GCPtr pGC,
- Boolean foreground,
- SpanDataPtr spanData,
- LineFacePtr leftFace, LineFacePtr rightFace, double xorg, double yorg, Boolean isInt)
-{
- DDXPointPtr points;
- int *widths;
- int xorgi = 0, yorgi = 0;
- Spans spanRec;
- int n;
- PolyEdgeRec edge1, edge2;
- int edgey1, edgey2;
- Boolean edgeleft1, edgeleft2;
-
- if (isInt) {
- xorgi = leftFace ? leftFace->x : rightFace->x;
- yorgi = leftFace ? leftFace->y : rightFace->y;
- }
- edgey1 = 65536;
- edgey2 = 65536;
- edge1.x = 0; /* not used, keep memory checkers happy */
- edge1.dy = -1;
- edge2.x = 0; /* not used, keep memory checkers happy */
- edge2.dy = -1;
- edgeleft1 = FALSE;
- edgeleft2 = FALSE;
- if ((pGC->lineStyle != LineSolid || pGC->lineWidth > 2) &&
- ((pGC->capStyle == CapRound && pGC->joinStyle != JoinRound) ||
- (pGC->joinStyle == JoinRound && pGC->capStyle == CapButt))) {
- if (isInt) {
- xorg = (double) xorgi;
- yorg = (double) yorgi;
- }
- if (leftFace && rightFace) {
- miRoundJoinClip (leftFace, rightFace, &edge1, &edge2,
- &edgey1, &edgey2, &edgeleft1, &edgeleft2);
- } else if (leftFace) {
- edgey1 = miRoundCapClip (leftFace, isInt, &edge1, &edgeleft1);
- } else if (rightFace) {
- edgey2 = miRoundCapClip (rightFace, isInt, &edge2, &edgeleft2);
- }
- isInt = FALSE;
- }
- if (!spanData) {
- points = (DDXPointRec *)xalloc (sizeof (DDXPointRec) * pGC->lineWidth);
- if (!points)
- return;
- widths = (int *)xalloc (sizeof (int) * pGC->lineWidth);
- if (!widths) {
- xfree (points);
- return;
- }
- } else {
- points = (DDXPointRec *)xalloc (pGC->lineWidth * sizeof (DDXPointRec));
- if (!points)
- return;
- widths = (int *)xalloc (pGC->lineWidth * sizeof (int));
- if (!widths) {
- xfree (points);
- return;
- }
- spanRec.points = points;
- spanRec.widths = widths;
- }
- if (isInt)
- n = miLineArcI (pGC, xorgi, yorgi, points, widths);
- else
- n = miLineArcD (pGC, xorg, yorg, points, widths,
- &edge1, edgey1, edgeleft1, &edge2, edgey2, edgeleft2);
-
- if (!spanData) {
- (*pGC->ops->FillSpans) (pGC, n, points, widths, TRUE, foreground);
- xfree (widths);
- xfree (points);
- } else {
- spanRec.count = n;
- AppendSpanGroup (pGC, foreground, &spanRec, spanData)
- }
-}
-
-static void
-miLineProjectingCap (GCPtr pGC, Boolean foreground,
- SpanDataPtr spanData, LineFacePtr face, Boolean isLeft,
- double xorg, double yorg, Boolean isInt)
-{
- int xorgi = 0, yorgi = 0;
- int lw;
- PolyEdgeRec lefts[2], rights[2];
- int lefty, righty, topy, bottomy;
- PolyEdgePtr left, right;
- PolyEdgePtr top, bottom;
- double xa, ya;
- double k;
- double xap, yap;
- int dx, dy;
- double projectXoff, projectYoff;
- double maxy;
- int finaly;
-
- if (isInt) {
- xorgi = face->x;
- yorgi = face->y;
- }
- lw = pGC->lineWidth;
- dx = face->dx;
- dy = face->dy;
- k = face->k;
- if (dy == 0) {
- lefts[0].height = lw;
- lefts[0].x = xorgi;
- if (isLeft)
- lefts[0].x -= (lw >> 1);
- lefts[0].stepx = 0;
- lefts[0].signdx = 1;
- lefts[0].e = -lw;
- lefts[0].dx = 0;
- lefts[0].dy = lw;
- rights[0].height = lw;
- rights[0].x = xorgi;
- if (!isLeft)
- rights[0].x += ((lw + 1) >> 1);
- rights[0].stepx = 0;
- rights[0].signdx = 1;
- rights[0].e = -lw;
- rights[0].dx = 0;
- rights[0].dy = lw;
- miFillPolyHelper (pGC, foreground, spanData, yorgi - (lw >> 1), lw, lefts, rights, 1, 1);
- } else if (dx == 0) {
- if (dy < 0) {
- dy = -dy;
- isLeft = !isLeft;
- }
- topy = yorgi;
- bottomy = yorgi + dy;
- if (isLeft)
- topy -= (lw >> 1);
- else
- bottomy += (lw >> 1);
- lefts[0].height = bottomy - topy;
- lefts[0].x = xorgi - (lw >> 1);
- lefts[0].stepx = 0;
- lefts[0].signdx = 1;
- lefts[0].e = -dy;
- lefts[0].dx = dx;
- lefts[0].dy = dy;
-
- rights[0].height = bottomy - topy;
- rights[0].x = lefts[0].x + (lw - 1);
- rights[0].stepx = 0;
- rights[0].signdx = 1;
- rights[0].e = -dy;
- rights[0].dx = dx;
- rights[0].dy = dy;
- miFillPolyHelper (pGC, foreground, spanData, topy, bottomy - topy, lefts, rights, 1, 1);
- } else {
- xa = face->xa;
- ya = face->ya;
- projectXoff = -ya;
- projectYoff = xa;
- if (dx < 0) {
- right = &rights[1];
- left = &lefts[0];
- top = &rights[0];
- bottom = &lefts[1];
- } else {
- right = &rights[0];
- left = &lefts[1];
- top = &lefts[0];
- bottom = &rights[1];
- }
- if (isLeft) {
- righty = miPolyBuildEdge (xa, ya, k, dx, dy, xorgi, yorgi, 0, right);
-
- xa = -xa;
- ya = -ya;
- k = -k;
- lefty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,
- k, dx, dy, xorgi, yorgi, 1, left);
- if (dx > 0) {
- ya = -ya;
- xa = -xa;
- }
- xap = xa - projectXoff;
- yap = ya - projectYoff;
- topy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,
- -dy, dx, xorgi, yorgi, dx > 0, top);
- bottomy = miPolyBuildEdge (xa, ya, 0.0, -dy, dx, xorgi, yorgi, dx < 0, bottom);
- maxy = -ya;
- } else {
- righty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,
- k, dx, dy, xorgi, yorgi, 0, right);
-
- xa = -xa;
- ya = -ya;
- k = -k;
- lefty = miPolyBuildEdge (xa, ya, k, dx, dy, xorgi, yorgi, 1, left);
- if (dx > 0) {
- ya = -ya;
- xa = -xa;
- }
- xap = xa - projectXoff;
- yap = ya - projectYoff;
- topy = miPolyBuildEdge (xa, ya, 0.0, -dy, dx, xorgi, xorgi, dx > 0, top);
- bottomy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,
- -dy, dx, xorgi, xorgi, dx < 0, bottom);
- maxy = -ya + projectYoff;
- }
- finaly = ICEIL (maxy) + yorgi;
- if (dx < 0) {
- left->height = bottomy - lefty;
- right->height = finaly - righty;
- top->height = righty - topy;
- } else {
- right->height = bottomy - righty;
- left->height = finaly - lefty;
- top->height = lefty - topy;
- }
- bottom->height = finaly - bottomy;
- miFillPolyHelper (pGC, foreground, spanData, topy,
- bottom->height + bottomy - topy, lefts, rights, 2, 2);
- }
-}
-
-static void
-miWideSegment (GCPtr pGC,
- Boolean foreground,
- SpanDataPtr spanData,
- int x1,
- int y1,
- int x2,
- int y2,
- Boolean projectLeft, Boolean projectRight, LineFacePtr leftFace, LineFacePtr rightFace)
-{
- double l, L, r;
- double xa, ya;
- double projectXoff = 0.0, projectYoff = 0.0;
- double k;
- double maxy;
- int x, y;
- int dx, dy;
- int finaly;
- PolyEdgePtr left, right;
- PolyEdgePtr top, bottom;
- int lefty, righty, topy, bottomy;
- int signdx;
- PolyEdgeRec lefts[2], rights[2];
- LineFacePtr tface;
- int lw = pGC->lineWidth;
-
- /* draw top-to-bottom always */
- if (y2 < y1 || (y2 == y1 && x2 < x1)) {
- x = x1;
- x1 = x2;
- x2 = x;
-
- y = y1;
- y1 = y2;
- y2 = y;
-
- x = projectLeft;
- projectLeft = projectRight;
- projectRight = x;
-
- tface = leftFace;
- leftFace = rightFace;
- rightFace = tface;
- }
-
- dy = y2 - y1;
- signdx = 1;
- dx = x2 - x1;
- if (dx < 0)
- signdx = -1;
-
- leftFace->x = x1;
- leftFace->y = y1;
- leftFace->dx = dx;
- leftFace->dy = dy;
-
- rightFace->x = x2;
- rightFace->y = y2;
- rightFace->dx = -dx;
- rightFace->dy = -dy;
-
- if (dy == 0) {
- rightFace->xa = 0;
- rightFace->ya = (double) lw / 2.0;
- rightFace->k = -(double) (lw * dx) / 2.0;
- leftFace->xa = 0;
- leftFace->ya = -rightFace->ya;
- leftFace->k = rightFace->k;
- x = x1;
- if (projectLeft)
- x -= (lw >> 1);
- y = y1 - (lw >> 1);
- dx = x2 - x;
- if (projectRight)
- dx += ((lw + 1) >> 1);
- dy = lw;
- miFillRectPolyHelper (pGC, foreground, spanData, x, y, dx, dy);
- } else if (dx == 0) {
- leftFace->xa = (double) lw / 2.0;
- leftFace->ya = 0;
- leftFace->k = (double) (lw * dy) / 2.0;
- rightFace->xa = -leftFace->xa;
- rightFace->ya = 0;
- rightFace->k = leftFace->k;
- y = y1;
- if (projectLeft)
- y -= lw >> 1;
- x = x1 - (lw >> 1);
- dy = y2 - y;
- if (projectRight)
- dy += ((lw + 1) >> 1);
- dx = lw;
- miFillRectPolyHelper (pGC, foreground, spanData, x, y, dx, dy);
- } else {
- l = ((double) lw) / 2.0;
- L = hypot ((double) dx, (double) dy);
-
- if (dx < 0) {
- right = &rights[1];
- left = &lefts[0];
- top = &rights[0];
- bottom = &lefts[1];
- } else {
- right = &rights[0];
- left = &lefts[1];
- top = &lefts[0];
- bottom = &rights[1];
- }
- r = l / L;
-
- /* coord of upper bound at integral y */
- ya = -r * dx;
- xa = r * dy;
-
- if (projectLeft | projectRight) {
- projectXoff = -ya;
- projectYoff = xa;
- }
-
- /* xa * dy - ya * dx */
- k = l * L;
-
- leftFace->xa = xa;
- leftFace->ya = ya;
- leftFace->k = k;
- rightFace->xa = -xa;
- rightFace->ya = -ya;
- rightFace->k = k;
-
- if (projectLeft)
- righty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,
- k, dx, dy, x1, y1, 0, right);
- else
- righty = miPolyBuildEdge (xa, ya, k, dx, dy, x1, y1, 0, right);
-
- /* coord of lower bound at integral y */
- ya = -ya;
- xa = -xa;
-
- /* xa * dy - ya * dx */
- k = -k;
-
- if (projectLeft)
- lefty = miPolyBuildEdge (xa - projectXoff, ya - projectYoff,
- k, dx, dy, x1, y1, 1, left);
- else
- lefty = miPolyBuildEdge (xa, ya, k, dx, dy, x1, y1, 1, left);
-
- /* coord of top face at integral y */
-
- if (signdx > 0) {
- ya = -ya;
- xa = -xa;
- }
-
- if (projectLeft) {
- double xap = xa - projectXoff;
- double yap = ya - projectYoff;
- topy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy, -dy, dx, x1, y1, dx > 0, top);
- } else
- topy = miPolyBuildEdge (xa, ya, 0.0, -dy, dx, x1, y1, dx > 0, top);
-
- /* coord of bottom face at integral y */
-
- if (projectRight) {
- double xap = xa + projectXoff;
- double yap = ya + projectYoff;
- bottomy = miPolyBuildEdge (xap, yap, xap * dx + yap * dy,
- -dy, dx, x2, y2, dx < 0, bottom);
- maxy = -ya + projectYoff;
- } else {
- bottomy = miPolyBuildEdge (xa, ya, 0.0, -dy, dx, x2, y2, dx < 0, bottom);
- maxy = -ya;
- }
-
- finaly = ICEIL (maxy) + y2;
-
- if (dx < 0) {
- left->height = bottomy - lefty;
- right->height = finaly - righty;
- top->height = righty - topy;
- } else {
- right->height = bottomy - righty;
- left->height = finaly - lefty;
- top->height = lefty - topy;
- }
- bottom->height = finaly - bottomy;
- miFillPolyHelper (pGC, foreground, spanData, topy,
- bottom->height + bottomy - topy, lefts, rights, 2, 2);
- }
-}
-
-static SpanDataPtr
-miSetupSpanData (GCPtr pGC, SpanDataPtr spanData, int npt)
-{
- if ((npt < 3 && pGC->capStyle != CapRound) || miSpansEasyRop (pGC->alu))
- return (SpanDataPtr) NULL;
- if (pGC->lineStyle == LineDoubleDash)
- miInitSpanGroup (&spanData->bgGroup);
- miInitSpanGroup (&spanData->fgGroup);
- return spanData;
-}
-
-static void
-miCleanupSpanData (GCPtr pGC, SpanDataPtr spanData)
-{
- if (pGC->lineStyle == LineDoubleDash) {
- miFillUniqueSpanGroup (pGC, &spanData->bgGroup, FALSE);
- miFreeSpanGroup (&spanData->bgGroup);
- }
- miFillUniqueSpanGroup (pGC, &spanData->fgGroup, TRUE);
- miFreeSpanGroup (&spanData->fgGroup);
-}
-
-void
-miWideLine (GCPtr pGC, int mode, int npt, DDXPointPtr pPts)
-{
- int x1, y1, x2, y2;
- SpanDataRec spanDataRec;
- SpanDataPtr spanData;
- Boolean projectLeft, projectRight;
- LineFaceRec leftFace, rightFace, prevRightFace;
- LineFaceRec firstFace;
- int first;
- Boolean somethingDrawn = FALSE;
- Boolean selfJoin;
-
- spanData = miSetupSpanData (pGC, &spanDataRec, npt);
- x2 = pPts->x;
- y2 = pPts->y;
- first = TRUE;
- selfJoin = FALSE;
- if (npt > 1) {
- if (mode == CoordModePrevious) {
- int nptTmp;
- DDXPointPtr pPtsTmp;
-
- x1 = x2;
- y1 = y2;
- nptTmp = npt;
- pPtsTmp = pPts + 1;
- while (--nptTmp) {
- x1 += pPtsTmp->x;
- y1 += pPtsTmp->y;
- ++pPtsTmp;
- }
- if (x2 == x1 && y2 == y1)
- selfJoin = TRUE;
- } else if (x2 == pPts[npt - 1].x && y2 == pPts[npt - 1].y) {
- selfJoin = TRUE;
- }
- }
- projectLeft = pGC->capStyle == CapProjecting && !selfJoin;
- projectRight = FALSE;
- while (--npt) {
- x1 = x2;
- y1 = y2;
- ++pPts;
- x2 = pPts->x;
- y2 = pPts->y;
- if (mode == CoordModePrevious) {
- x2 += x1;
- y2 += y1;
- }
- if (x1 != x2 || y1 != y2) {
- somethingDrawn = TRUE;
- if (npt == 1 && pGC->capStyle == CapProjecting && !selfJoin)
- projectRight = TRUE;
- miWideSegment (pGC, TRUE, spanData, x1, y1, x2, y2,
- projectLeft, projectRight, &leftFace, &rightFace);
- if (first) {
- if (selfJoin)
- firstFace = leftFace;
- else if (pGC->capStyle == CapRound) {
- if (pGC->lineWidth == 1 && !spanData)
- miLineOnePoint (pGC, TRUE, spanData, x1, y1);
- else
- miLineArc (pGC, TRUE, spanData,
- &leftFace, (LineFacePtr) NULL, (double) 0.0, (double) 0.0, TRUE);
- }
- } else {
- miLineJoin (pGC, TRUE, spanData, &leftFace, &prevRightFace);
- }
- prevRightFace = rightFace;
- first = FALSE;
- projectLeft = FALSE;
- }
- if (npt == 1 && somethingDrawn) {
- if (selfJoin)
- miLineJoin (pGC, TRUE, spanData, &firstFace, &rightFace);
- else if (pGC->capStyle == CapRound) {
- if (pGC->lineWidth == 1 && !spanData)
- miLineOnePoint (pGC, TRUE, spanData, x2, y2);
- else
- miLineArc (pGC, TRUE, spanData,
- (LineFacePtr) NULL, &rightFace, (double) 0.0, (double) 0.0, TRUE);
- }
- }
- }
- /* handle crock where all points are coincedent */
- if (!somethingDrawn) {
- projectLeft = pGC->capStyle == CapProjecting;
- miWideSegment (pGC, TRUE, spanData,
- x2, y2, x2, y2, projectLeft, projectLeft, &leftFace, &rightFace);
- if (pGC->capStyle == CapRound) {
- miLineArc (pGC, TRUE, spanData,
- &leftFace, (LineFacePtr) NULL, (double) 0.0, (double) 0.0, TRUE);
- rightFace.dx = -1; /* sleezy hack to make it work */
- miLineArc (pGC, TRUE, spanData,
- (LineFacePtr) NULL, &rightFace, (double) 0.0, (double) 0.0, TRUE);
- }
- }
- if (spanData)
- miCleanupSpanData (pGC, spanData);
-}
-
-#define V_TOP 0
-#define V_RIGHT 1
-#define V_BOTTOM 2
-#define V_LEFT 3
-
-static void
-miWideDashSegment (GCPtr pGC,
- SpanDataPtr spanData,
- int *pDashOffset,
- int *pDashIndex,
- int x1,
- int y1,
- int x2,
- int y2,
- Boolean projectLeft, Boolean projectRight, LineFacePtr leftFace, LineFacePtr rightFace)
-{
- int dashIndex, dashRemain;
- unsigned char *pDash;
- double L, l;
- double k;
- PolyVertexRec vertices[4];
- PolyVertexRec saveRight = { 0 }, saveBottom;
- PolySlopeRec slopes[4];
- PolyEdgeRec left[2], right[2];
- LineFaceRec lcapFace, rcapFace;
- int nleft, nright;
- int h;
- int y;
- int dy, dx;
- Boolean foreground;
- double LRemain;
- double r;
- double rdx, rdy;
- double dashDx, dashDy;
- double saveK = 0.0;
- Boolean first = TRUE;
- double lcenterx, lcentery, rcenterx = 0.0, rcentery = 0.0;
-
- dx = x2 - x1;
- dy = y2 - y1;
- dashIndex = *pDashIndex;
- pDash = pGC->dash;
- dashRemain = pDash[dashIndex] - *pDashOffset;
-
- l = ((double) pGC->lineWidth) / 2.0;
- if (dx == 0) {
- L = dy;
- rdx = 0;
- rdy = l;
- if (dy < 0) {
- L = -dy;
- rdy = -l;
- }
- } else if (dy == 0) {
- L = dx;
- rdx = l;
- rdy = 0;
- if (dx < 0) {
- L = -dx;
- rdx = -l;
- }
- } else {
- L = hypot ((double) dx, (double) dy);
- r = l / L;
-
- rdx = r * dx;
- rdy = r * dy;
- }
- k = l * L;
- LRemain = L;
- /* All position comments are relative to a line with dx and dy > 0,
- * but the code does not depend on this */
- /* top */
- slopes[V_TOP].dx = dx;
- slopes[V_TOP].dy = dy;
- slopes[V_TOP].k = k;
- /* right */
- slopes[V_RIGHT].dx = -dy;
- slopes[V_RIGHT].dy = dx;
- slopes[V_RIGHT].k = 0;
- /* bottom */
- slopes[V_BOTTOM].dx = -dx;
- slopes[V_BOTTOM].dy = -dy;
- slopes[V_BOTTOM].k = k;
- /* left */
- slopes[V_LEFT].dx = dy;
- slopes[V_LEFT].dy = -dx;
- slopes[V_LEFT].k = 0;
-
- /* preload the start coordinates */
- vertices[V_RIGHT].x = vertices[V_TOP].x = rdy;
- vertices[V_RIGHT].y = vertices[V_TOP].y = -rdx;
-
- vertices[V_BOTTOM].x = vertices[V_LEFT].x = -rdy;
- vertices[V_BOTTOM].y = vertices[V_LEFT].y = rdx;
-
- if (projectLeft) {
- vertices[V_TOP].x -= rdx;
- vertices[V_TOP].y -= rdy;
-
- vertices[V_LEFT].x -= rdx;
- vertices[V_LEFT].y -= rdy;
-
- slopes[V_LEFT].k = rdx * dx + rdy * dy;
- }
-
- lcenterx = x1;
- lcentery = y1;
-
- if (pGC->capStyle == CapRound) {
- lcapFace.dx = dx;
- lcapFace.dy = dy;
- lcapFace.x = x1;
- lcapFace.y = y1;
-
- rcapFace.dx = -dx;
- rcapFace.dy = -dy;
- rcapFace.x = x1;
- rcapFace.y = y1;
- }
- while (LRemain > dashRemain) {
- dashDx = (dashRemain * dx) / L;
- dashDy = (dashRemain * dy) / L;
-
- rcenterx = lcenterx + dashDx;
- rcentery = lcentery + dashDy;
-
- vertices[V_RIGHT].x += dashDx;
- vertices[V_RIGHT].y += dashDy;
-
- vertices[V_BOTTOM].x += dashDx;
- vertices[V_BOTTOM].y += dashDy;
-
- slopes[V_RIGHT].k = vertices[V_RIGHT].x * dx + vertices[V_RIGHT].y * dy;
-
- if (pGC->lineStyle == LineDoubleDash || !(dashIndex & 1)) {
- if (pGC->lineStyle == LineOnOffDash && pGC->capStyle == CapProjecting) {
- saveRight = vertices[V_RIGHT];
- saveBottom = vertices[V_BOTTOM];
- saveK = slopes[V_RIGHT].k;
-
- if (!first) {
- vertices[V_TOP].x -= rdx;
- vertices[V_TOP].y -= rdy;
-
- vertices[V_LEFT].x -= rdx;
- vertices[V_LEFT].y -= rdy;
-
- slopes[V_LEFT].k = vertices[V_LEFT].x *
- slopes[V_LEFT].dy - vertices[V_LEFT].y * slopes[V_LEFT].dx;
- }
-
- vertices[V_RIGHT].x += rdx;
- vertices[V_RIGHT].y += rdy;
-
- vertices[V_BOTTOM].x += rdx;
- vertices[V_BOTTOM].y += rdy;
-
- slopes[V_RIGHT].k = vertices[V_RIGHT].x *
- slopes[V_RIGHT].dy - vertices[V_RIGHT].y * slopes[V_RIGHT].dx;
- }
- y = miPolyBuildPoly (vertices, slopes, 4, x1, y1, left, right, &nleft, &nright, &h);
- foreground = (dashIndex & 1) == 0;
- miFillPolyHelper (pGC, foreground, spanData, y, h, left, right, nleft, nright);
-
- if (pGC->lineStyle == LineOnOffDash) {
- switch (pGC->capStyle) {
- case CapProjecting:
- vertices[V_BOTTOM] = saveBottom;
- vertices[V_RIGHT] = saveRight;
- slopes[V_RIGHT].k = saveK;
- break;
- case CapRound:
- if (!first) {
- if (dx < 0) {
- lcapFace.xa = -vertices[V_LEFT].x;
- lcapFace.ya = -vertices[V_LEFT].y;
- lcapFace.k = slopes[V_LEFT].k;
- } else {
- lcapFace.xa = vertices[V_TOP].x;
- lcapFace.ya = vertices[V_TOP].y;
- lcapFace.k = -slopes[V_LEFT].k;
- }
- miLineArc (pGC, foreground, spanData,
- &lcapFace, (LineFacePtr) NULL, lcenterx, lcentery, FALSE);
- }
- if (dx < 0) {
- rcapFace.xa = vertices[V_BOTTOM].x;
- rcapFace.ya = vertices[V_BOTTOM].y;
- rcapFace.k = slopes[V_RIGHT].k;
- } else {
- rcapFace.xa = -vertices[V_RIGHT].x;
- rcapFace.ya = -vertices[V_RIGHT].y;
- rcapFace.k = -slopes[V_RIGHT].k;
- }
- miLineArc (pGC, foreground, spanData,
- (LineFacePtr) NULL, &rcapFace, rcenterx, rcentery, FALSE);
- break;
- }
- }
- }
- LRemain -= dashRemain;
- ++dashIndex;
- if (dashIndex == pGC->numInDashList)
- dashIndex = 0;
- dashRemain = pDash[dashIndex];
-
- lcenterx = rcenterx;
- lcentery = rcentery;
-
- vertices[V_TOP] = vertices[V_RIGHT];
- vertices[V_LEFT] = vertices[V_BOTTOM];
- slopes[V_LEFT].k = -slopes[V_RIGHT].k;
- first = FALSE;
- }
-
- if (pGC->lineStyle == LineDoubleDash || !(dashIndex & 1)) {
- vertices[V_TOP].x -= dx;
- vertices[V_TOP].y -= dy;
-
- vertices[V_LEFT].x -= dx;
- vertices[V_LEFT].y -= dy;
-
- vertices[V_RIGHT].x = rdy;
- vertices[V_RIGHT].y = -rdx;
-
- vertices[V_BOTTOM].x = -rdy;
- vertices[V_BOTTOM].y = rdx;
-
-
- if (projectRight) {
- vertices[V_RIGHT].x += rdx;
- vertices[V_RIGHT].y += rdy;
-
- vertices[V_BOTTOM].x += rdx;
- vertices[V_BOTTOM].y += rdy;
- slopes[V_RIGHT].k = vertices[V_RIGHT].x *
- slopes[V_RIGHT].dy - vertices[V_RIGHT].y * slopes[V_RIGHT].dx;
- } else
- slopes[V_RIGHT].k = 0;
-
- if (!first && pGC->lineStyle == LineOnOffDash && pGC->capStyle == CapProjecting) {
- vertices[V_TOP].x -= rdx;
- vertices[V_TOP].y -= rdy;
-
- vertices[V_LEFT].x -= rdx;
- vertices[V_LEFT].y -= rdy;
- slopes[V_LEFT].k = vertices[V_LEFT].x *
- slopes[V_LEFT].dy - vertices[V_LEFT].y * slopes[V_LEFT].dx;
- } else
- slopes[V_LEFT].k += dx * dx + dy * dy;
-
-
- y = miPolyBuildPoly (vertices, slopes, 4, x2, y2, left, right, &nleft, &nright, &h);
-
- foreground = (dashIndex & 1) == 0;
- miFillPolyHelper (pGC, foreground, spanData, y, h, left, right, nleft, nright);
- if (!first && pGC->lineStyle == LineOnOffDash && pGC->capStyle == CapRound) {
- lcapFace.x = x2;
- lcapFace.y = y2;
- if (dx < 0) {
- lcapFace.xa = -vertices[V_LEFT].x;
- lcapFace.ya = -vertices[V_LEFT].y;
- lcapFace.k = slopes[V_LEFT].k;
- } else {
- lcapFace.xa = vertices[V_TOP].x;
- lcapFace.ya = vertices[V_TOP].y;
- lcapFace.k = -slopes[V_LEFT].k;
- }
- miLineArc (pGC, foreground, spanData,
- &lcapFace, (LineFacePtr) NULL, rcenterx, rcentery, FALSE);
- }
- }
- dashRemain = (int)(((double) dashRemain) - LRemain);
- if (dashRemain == 0) {
- dashIndex++;
- if (dashIndex == pGC->numInDashList)
- dashIndex = 0;
- dashRemain = pDash[dashIndex];
- }
-
- leftFace->x = x1;
- leftFace->y = y1;
- leftFace->dx = dx;
- leftFace->dy = dy;
- leftFace->xa = rdy;
- leftFace->ya = -rdx;
- leftFace->k = k;
-
- rightFace->x = x2;
- rightFace->y = y2;
- rightFace->dx = -dx;
- rightFace->dy = -dy;
- rightFace->xa = -rdy;
- rightFace->ya = rdx;
- rightFace->k = k;
-
- *pDashIndex = dashIndex;
- *pDashOffset = pDash[dashIndex] - dashRemain;
-}
-
-void
-miWideDash (GCPtr pGC, int mode, int npt, DDXPointPtr pPts)
-{
- int x1, y1, x2, y2;
- Boolean foreground;
- Boolean projectLeft, projectRight;
- LineFaceRec leftFace, rightFace, prevRightFace;
- LineFaceRec firstFace;
- int first;
- int dashIndex, dashOffset;
- int prevDashIndex;
- SpanDataRec spanDataRec;
- SpanDataPtr spanData;
- Boolean somethingDrawn = FALSE;
- Boolean selfJoin;
- Boolean endIsFg = FALSE, startIsFg = FALSE;
- Boolean firstIsFg = FALSE, prevIsFg = FALSE;
-
- if (npt == 0)
- return;
- spanData = miSetupSpanData (pGC, &spanDataRec, npt);
- x2 = pPts->x;
- y2 = pPts->y;
- first = TRUE;
- selfJoin = FALSE;
- if (mode == CoordModePrevious) {
- int nptTmp;
- DDXPointPtr pPtsTmp;
-
- x1 = x2;
- y1 = y2;
- nptTmp = npt;
- pPtsTmp = pPts + 1;
- while (--nptTmp) {
- x1 += pPtsTmp->x;
- y1 += pPtsTmp->y;
- ++pPtsTmp;
- }
- if (x2 == x1 && y2 == y1)
- selfJoin = TRUE;
- } else if (x2 == pPts[npt - 1].x && y2 == pPts[npt - 1].y) {
- selfJoin = TRUE;
- }
- projectLeft = pGC->capStyle == CapProjecting && !selfJoin;
- projectRight = FALSE;
- dashIndex = 0;
- dashOffset = 0;
- miStepDash ((int) pGC->dashOffset, &dashIndex,
- pGC->dash, (int) pGC->numInDashList, &dashOffset);
- while (--npt) {
- x1 = x2;
- y1 = y2;
- ++pPts;
- x2 = pPts->x;
- y2 = pPts->y;
- if (mode == CoordModePrevious) {
- x2 += x1;
- y2 += y1;
- }
- if (x1 != x2 || y1 != y2) {
- somethingDrawn = TRUE;
- if (npt == 1 && pGC->capStyle == CapProjecting && (!selfJoin || !firstIsFg))
- projectRight = TRUE;
- prevDashIndex = dashIndex;
- miWideDashSegment (pGC, spanData, &dashOffset, &dashIndex,
- x1, y1, x2, y2, projectLeft, projectRight, &leftFace, &rightFace);
- startIsFg = !(prevDashIndex & 1);
- endIsFg = (dashIndex & 1) ^ (dashOffset != 0);
- if (pGC->lineStyle == LineDoubleDash || startIsFg) {
- foreground = startIsFg;
- if (first || (pGC->lineStyle == LineOnOffDash && !prevIsFg)) {
- if (first && selfJoin) {
- firstFace = leftFace;
- firstIsFg = startIsFg;
- } else if (pGC->capStyle == CapRound)
- miLineArc (pGC, foreground, spanData,
- &leftFace, (LineFacePtr) NULL, (double) 0.0, (double) 0.0, TRUE);
- } else {
- miLineJoin (pGC, foreground, spanData, &leftFace, &prevRightFace);
- }
- }
- prevRightFace = rightFace;
- prevIsFg = endIsFg;
- first = FALSE;
- projectLeft = FALSE;
- }
- if (npt == 1 && somethingDrawn) {
- if (pGC->lineStyle == LineDoubleDash || endIsFg) {
- foreground = endIsFg;
- if (selfJoin && (pGC->lineStyle == LineDoubleDash || firstIsFg)) {
- miLineJoin (pGC, foreground, spanData, &firstFace, &rightFace);
- } else {
- if (pGC->capStyle == CapRound)
- miLineArc (pGC, foreground, spanData,
- (LineFacePtr) NULL, &rightFace,
- (double) 0.0, (double) 0.0, TRUE);
- }
- } else {
- /* glue a cap to the start of the line if
- * we're OnOffDash and ended on odd dash
- */
- if (selfJoin && firstIsFg) {
- foreground = TRUE;
- if (pGC->capStyle == CapProjecting)
- miLineProjectingCap (pGC, foreground, spanData,
- &firstFace, TRUE, (double) 0.0, (double) 0.0, TRUE);
- else if (pGC->capStyle == CapRound)
- miLineArc (pGC, foreground, spanData,
- &firstFace, (LineFacePtr) NULL,
- (double) 0.0, (double) 0.0, TRUE);
- }
- }
- }
- }
- /* handle crock where all points are coincident */
- if (!somethingDrawn && (pGC->lineStyle == LineDoubleDash || !(dashIndex & 1))) {
- /* not the same as endIsFg computation above */
- foreground = (dashIndex & 1) == 0;
- switch (pGC->capStyle) {
- case CapRound:
- miLineArc (pGC, foreground, spanData,
- (LineFacePtr) NULL, (LineFacePtr) NULL, (double) x2, (double) y2, FALSE);
- break;
- case CapProjecting:
- x1 = pGC->lineWidth;
- miFillRectPolyHelper (pGC, foreground, spanData,
- x2 - (x1 >> 1), y2 - (x1 >> 1), x1, x1);
- break;
- }
- }
- if (spanData)
- miCleanupSpanData (pGC, spanData);
-}
-
-#undef ExchangeSpans
-#define ExchangeSpans(a, b) \
-{ \
- DDXPointRec tpt; \
- int tw; \
- \
- tpt = spans[a]; spans[a] = spans[b]; spans[b] = tpt; \
- tw = widths[a]; widths[a] = widths[b]; widths[b] = tw; \
-}
-
-static void QuickSortSpans(
- DDXPointRec spans[],
- int widths[],
- int numSpans)
-{
- int y;
- int i, j, m;
- DDXPointPtr r;
-
- /* Always called with numSpans > 1 */
- /* Sorts only by y, doesn't bother to sort by x */
-
- do
- {
- if (numSpans < 9)
- {
- /* Do insertion sort */
- int yprev;
-
- yprev = spans[0].y;
- i = 1;
- do
- { /* while i != numSpans */
- y = spans[i].y;
- if (yprev > y)
- {
- /* spans[i] is out of order. Move into proper location. */
- DDXPointRec tpt;
- int tw, k;
-
- for (j = 0; y >= spans[j].y; j++) {}
- tpt = spans[i];
- tw = widths[i];
- for (k = i; k != j; k--)
- {
- spans[k] = spans[k-1];
- widths[k] = widths[k-1];
- }
- spans[j] = tpt;
- widths[j] = tw;
- y = spans[i].y;
- } /* if out of order */
- yprev = y;
- i++;
- } while (i != numSpans);
- return;
- }
-
- /* Choose partition element, stick in location 0 */
- m = numSpans / 2;
- if (spans[m].y > spans[0].y) ExchangeSpans(m, 0);
- if (spans[m].y > spans[numSpans-1].y) ExchangeSpans(m, numSpans-1);
- if (spans[m].y > spans[0].y) ExchangeSpans(m, 0);
- y = spans[0].y;
-
- /* Partition array */
- i = 0;
- j = numSpans;
- do
- {
- r = &(spans[i]);
- do
- {
- r++;
- i++;
- } while (i != numSpans && r->y < y);
- r = &(spans[j]);
- do
- {
- r--;
- j--;
- } while (y < r->y);
- if (i < j)
- ExchangeSpans(i, j);
- } while (i < j);
-
- /* Move partition element back to middle */
- ExchangeSpans(0, j);
-
- /* Recurse */
- if (numSpans-j-1 > 1)
- QuickSortSpans(&spans[j+1], &widths[j+1], numSpans-j-1);
- numSpans = j;
- } while (numSpans > 1);
-}
-
-#define NextBand() \
-{ \
- clipy1 = pboxBandStart->y1; \
- clipy2 = pboxBandStart->y2; \
- pboxBandEnd = pboxBandStart + 1; \
- while (pboxBandEnd != pboxLast && pboxBandEnd->y1 == clipy1) { \
- pboxBandEnd++; \
- } \
- for (; ppt != pptLast && ppt->y < clipy1; ppt++, pwidth++) {} \
-}
-
-/*
- Clip a list of scanlines to a region. The caller has allocated the
- space. FSorted is non-zero if the scanline origins are in ascending
- order.
- returns the number of new, clipped scanlines.
-*/
-
-int spice_canvas_clip_spans(pixman_region32_t *prgnDst,
- DDXPointPtr ppt,
- int *pwidth,
- int nspans,
- DDXPointPtr pptNew,
- int *pwidthNew,
- int fSorted)
-{
- DDXPointPtr pptLast;
- int *pwidthNewStart; /* the vengeance of Xerox! */
- int y, x1, x2;
- int numRects;
- pixman_box32_t *pboxBandStart;
-
- pptLast = ppt + nspans;
- pwidthNewStart = pwidthNew;
-
- pboxBandStart = pixman_region32_rectangles (prgnDst, &numRects);
-
- if (numRects == 1) {
- /* Do special fast code with clip boundaries in registers(?) */
- /* It doesn't pay much to make use of fSorted in this case,
- so we lump everything together. */
-
- int clipx1, clipx2, clipy1, clipy2;
-
- clipx1 = pboxBandStart->x1;
- clipy1 = pboxBandStart->y1;
- clipx2 = pboxBandStart->x2;
- clipy2 = pboxBandStart->y2;
-
- for (; ppt != pptLast; ppt++, pwidth++) {
- y = ppt->y;
- x1 = ppt->x;
- if (clipy1 <= y && y < clipy2) {
- x2 = x1 + *pwidth;
- if (x1 < clipx1)
- x1 = clipx1;
- if (x2 > clipx2)
- x2 = clipx2;
- if (x1 < x2) {
- /* part of span in clip rectangle */
- pptNew->x = x1;
- pptNew->y = y;
- *pwidthNew = x2 - x1;
- pptNew++;
- pwidthNew++;
- }
- }
- } /* end for */
- } else if (numRects != 0) {
- /* Have to clip against many boxes */
- pixman_box32_t *pboxBandEnd, *pbox, *pboxLast;
- int clipy1, clipy2;
-
- /* In this case, taking advantage of sorted spans gains more than
- the sorting costs. */
- if ((! fSorted) && (nspans > 1))
- QuickSortSpans(ppt, pwidth, nspans);
-
- pboxLast = pboxBandStart + numRects;
-
- NextBand();
-
- for (; ppt != pptLast; ) {
- y = ppt->y;
- if (y < clipy2) {
- /* span is in the current band */
- pbox = pboxBandStart;
- x1 = ppt->x;
- x2 = x1 + *pwidth;
- do { /* For each box in band */
- int newx1, newx2;
-
- newx1 = x1;
- newx2 = x2;
- if (newx1 < pbox->x1)
- newx1 = pbox->x1;
- if (newx2 > pbox->x2)
- newx2 = pbox->x2;
- if (newx1 < newx2) {
- /* Part of span in clip rectangle */
- pptNew->x = newx1;
- pptNew->y = y;
- *pwidthNew = newx2 - newx1;
- pptNew++;
- pwidthNew++;
- }
- pbox++;
- } while (pbox != pboxBandEnd);
- ppt++;
- pwidth++;
- } else {
- /* Move to next band, adjust ppt as needed */
- pboxBandStart = pboxBandEnd;
- if (pboxBandStart == pboxLast)
- break; /* We're completely done */
- NextBand();
- }
- }
- }
- return (pwidthNew - pwidthNewStart);
-}
diff --git a/common/lines.h b/common/lines.h
deleted file mode 100644
index 73eef9b..0000000
--- a/common/lines.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/***********************************************************
-
-Copyright 1987, 1998 The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-
-Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
-
- All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-******************************************************************/
-
-#ifndef LINES_H
-#define LINES_H
-
-#include <pixman_utils.h>
-#include <stdlib.h>
-#include <string.h>
-#include "draw.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct lineGC lineGC;
-
-typedef struct {
- void (*FillSpans)(lineGC * pGC,
- int num_spans, SpicePoint * points, int *widths,
- int sorted, int foreground);
- void (*FillRects)(lineGC * pGC,
- int nun_rects, pixman_rectangle32_t * rects,
- int foreground);
-} lineGCOps;
-
-struct lineGC {
- int width;
- int height;
- unsigned char alu;
- unsigned short lineWidth;
- unsigned short dashOffset;
- unsigned short numInDashList;
- unsigned char *dash;
- unsigned int lineStyle:2;
- unsigned int capStyle:2;
- unsigned int joinStyle:2;
- lineGCOps *ops;
-};
-
-/* CoordinateMode for drawing routines */
-
-#define CoordModeOrigin 0 /* relative to the origin */
-#define CoordModePrevious 1 /* relative to previous point */
-
-/* LineStyle */
-
-#define LineSolid 0
-#define LineOnOffDash 1
-#define LineDoubleDash 2
-
-/* capStyle */
-
-#define CapNotLast 0
-#define CapButt 1
-#define CapRound 2
-#define CapProjecting 3
-
-/* joinStyle */
-
-#define JoinMiter 0
-#define JoinRound 1
-#define JoinBevel 2
-
-extern void spice_canvas_zero_line(lineGC *pgc,
- int mode,
- int num_points,
- SpicePoint * points);
-extern void spice_canvas_zero_dash_line(lineGC * pgc,
- int mode,
- int n_points,
- SpicePoint * points);
-extern void spice_canvas_wide_dash_line(lineGC * pGC,
- int mode,
- int num_points,
- SpicePoint * points);
-extern void spice_canvas_wide_line(lineGC *pGC,
- int mode,
- int num_points,
- SpicePoint * points);
-extern int spice_canvas_clip_spans(pixman_region32_t *clip_region,
- SpicePoint *points,
- int *widths,
- int num_spans,
- SpicePoint *new_points,
- int *new_widths,
- int sorted);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LINES_H */
diff --git a/common/lz.c b/common/lz.c
deleted file mode 100644
index 5f51794..0000000
--- a/common/lz.c
+++ /dev/null
@@ -1,740 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
-
- Copyright (C) 2009 Red Hat, Inc. and/or its affiliates.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-
- This file incorporates work covered by the following copyright and
- permission notice:
- Copyright (C) 2007 Ariya Hidayat (ariya at kde.org)
- Copyright (C) 2006 Ariya Hidayat (ariya at kde.org)
- Copyright (C) 2005 Ariya Hidayat (ariya at kde.org)
-
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use, copy,
- modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
-
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "lz.h"
-
-#define DEBUG
-
-#ifdef DEBUG
-
-#define ASSERT(usr, x) \
- if (!(x)) (usr)->error(usr, "%s: ASSERT %s failed\n", __FUNCTION__, #x);
-
-#else
-
-#define ASSERT(usr, x)
-
-#endif
-
-#define HASH_LOG 13
-#define HASH_SIZE (1 << HASH_LOG)
-#define HASH_MASK (HASH_SIZE - 1)
-
-
-typedef struct LzImageSegment LzImageSegment;
-struct LzImageSegment {
- uint8_t *lines;
- uint8_t *lines_end;
- unsigned int size_delta; // total size of the previous segments in units of
- // pixels for rgb and bytes for plt.
- LzImageSegment *next;
-};
-
-// TODO: pack?
-typedef struct HashEntry {
- LzImageSegment *image_seg;
- uint8_t *ref;
-} HashEntry;
-
-typedef struct Encoder {
- LzUsrContext *usr;
-
- LzImageType type;
- const SpicePalette *palette; // for decoding images with palettes to rgb
- int stride; // stride is in bytes. For rgb must be equal to
- // width*bytes_per_pix.
- // For palettes stride can be bigger than width/pixels_per_byte by 1 only if
- // width%pixels_per_byte != 0.
- int height;
- int width; // the original width (in pixels)
-
- LzImageSegment *head_image_segs;
- LzImageSegment *tail_image_segs;
- LzImageSegment *free_image_segs;
-
- // the dictionary hash table is composed (1) a pointer to the segment the word was found in
- // (2) a pointer to the first byte in the segment that matches the word
- HashEntry htab[HASH_SIZE];
-
- uint8_t *io_start;
- uint8_t *io_now;
- uint8_t *io_end;
- size_t io_bytes_count;
-
- uint8_t *io_last_copy; // pointer to the last byte in which copy count was written
-} Encoder;
-
-/****************************************************/
-/* functions for managing the pool of image segments*/
-/****************************************************/
-static INLINE LzImageSegment *lz_alloc_image_seg(Encoder *encoder);
-static void lz_reset_image_seg(Encoder *encoder);
-static int lz_read_image_segments(Encoder *encoder, uint8_t *first_lines,
- unsigned int num_first_lines);
-
-
-// return a free image segment if one exists. Make allocation if needed. adds it to the
-// tail of the image segments lists
-static INLINE LzImageSegment *lz_alloc_image_seg(Encoder *encoder)
-{
- LzImageSegment *ret;
-
- if (encoder->free_image_segs) {
- ret = encoder->free_image_segs;
- encoder->free_image_segs = ret->next;
- } else {
- if (!(ret = (LzImageSegment *)encoder->usr->malloc(encoder->usr, sizeof(*ret)))) {
- return NULL;
- }
- }
-
- ret->next = NULL;
- if (encoder->tail_image_segs) {
- encoder->tail_image_segs->next = ret;
- }
- encoder->tail_image_segs = ret;
-
- if (!encoder->head_image_segs) {
- encoder->head_image_segs = ret;
- }
-
- return ret;
-}
-
-// adding seg to the head of free segments (lz_reset_image_seg removes it from used ones)
-static INLINE void __lz_free_image_seg(Encoder *encoder, LzImageSegment *seg)
-{
- seg->next = encoder->free_image_segs;
- encoder->free_image_segs = seg;
-}
-
-// moves all the used image segments to the free pool
-static void lz_reset_image_seg(Encoder *encoder)
-{
- while (encoder->head_image_segs) {
- LzImageSegment *seg = encoder->head_image_segs;
- encoder->head_image_segs = seg->next;
- __lz_free_image_seg(encoder, seg);
- }
- encoder->tail_image_segs = NULL;
-}
-
-static void lz_dealloc_free_segments(Encoder *encoder)
-{
- while (encoder->free_image_segs) {
- LzImageSegment *seg = encoder->free_image_segs;
- encoder->free_image_segs = seg->next;
- encoder->usr->free(encoder->usr, seg);
- }
-}
-
-// return FALSE when operation fails (due to failure in allocation)
-static int lz_read_image_segments(Encoder *encoder, uint8_t *first_lines,
- unsigned int num_first_lines)
-{
- LzImageSegment *image_seg;
- uint32_t size_delta = 0;
- unsigned int num_lines = num_first_lines;
- uint8_t* lines = first_lines;
- int row;
-
- ASSERT(encoder->usr, !encoder->head_image_segs);
-
- image_seg = lz_alloc_image_seg(encoder);
- if (!image_seg) {
- goto error_1;
- }
-
- image_seg->lines = lines;
- image_seg->lines_end = lines + num_lines * encoder->stride;
- image_seg->size_delta = size_delta;
-
- size_delta += num_lines * encoder->stride / RGB_BYTES_PER_PIXEL[encoder->type];
-
- for (row = num_first_lines; row < encoder->height; row += num_lines) {
- num_lines = encoder->usr->more_lines(encoder->usr, &lines);
- if (num_lines <= 0) {
- encoder->usr->error(encoder->usr, "more lines failed\n");
- }
- image_seg = lz_alloc_image_seg(encoder);
-
- if (!image_seg) {
- goto error_1;
- }
-
- image_seg->lines = lines;
- image_seg->lines_end = lines + num_lines * encoder->stride;
- image_seg->size_delta = size_delta;
-
- size_delta += num_lines * encoder->stride / RGB_BYTES_PER_PIXEL[encoder->type];
- }
-
- return TRUE;
-error_1:
- lz_reset_image_seg(encoder);
- return FALSE;
-}
-
-/**************************************************************************
-* Handling encoding and decoding of a byte
-***************************************************************************/
-static INLINE int more_io_bytes(Encoder *encoder)
-{
- uint8_t *io_ptr;
- int num_io_bytes = encoder->usr->more_space(encoder->usr, &io_ptr);
- encoder->io_bytes_count += num_io_bytes;
- encoder->io_now = io_ptr;
- encoder->io_end = encoder->io_now + num_io_bytes;
- return num_io_bytes;
-}
-
-static INLINE void encode(Encoder *encoder, uint8_t byte)
-{
- if (encoder->io_now == encoder->io_end) {
- if (more_io_bytes(encoder) <= 0) {
- encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
- }
- ASSERT(encoder->usr, encoder->io_now);
- }
-
- ASSERT(encoder->usr, encoder->io_now < encoder->io_end);
- *(encoder->io_now++) = byte;
-}
-
-static INLINE void encode_32(Encoder *encoder, unsigned int word)
-{
- encode(encoder, (uint8_t)(word >> 24));
- encode(encoder, (uint8_t)(word >> 16) & 0x0000ff);
- encode(encoder, (uint8_t)(word >> 8) & 0x0000ff);
- encode(encoder, (uint8_t)(word & 0x0000ff));
-}
-
-static INLINE void encode_copy_count(Encoder *encoder, uint8_t copy_count)
-{
- encode(encoder, copy_count);
- encoder->io_last_copy = encoder->io_now - 1; // io_now cannot be the first byte of the buffer
-}
-
-static INLINE void update_copy_count(Encoder *encoder, uint8_t copy_count)
-{
- ASSERT(encoder->usr, encoder->io_last_copy);
- *(encoder->io_last_copy) = copy_count;
-}
-
-static INLINE void encode_level(Encoder *encoder, uint8_t level_code)
-{
- *(encoder->io_start) |= level_code;
-}
-
-// decrease the io ptr by 1
-static INLINE void compress_output_prev(Encoder *encoder)
-{
- // io_now cannot be the first byte of the buffer
- encoder->io_now--;
- // the function should be called only when copy count is written unnecessarily by lz_compress
- ASSERT(encoder->usr, encoder->io_now == encoder->io_last_copy)
-}
-
-static int encoder_reset(Encoder *encoder, uint8_t *io_ptr, uint8_t *io_ptr_end)
-{
- ASSERT(encoder->usr, io_ptr <= io_ptr_end);
- encoder->io_bytes_count = io_ptr_end - io_ptr;
- encoder->io_start = io_ptr;
- encoder->io_now = io_ptr;
- encoder->io_end = io_ptr_end;
- encoder->io_last_copy = NULL;
-
- return TRUE;
-}
-
-static INLINE uint8_t decode(Encoder *encoder)
-{
- if (encoder->io_now == encoder->io_end) {
- int num_io_bytes = more_io_bytes(encoder);
- if (num_io_bytes <= 0) {
- encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
- }
- ASSERT(encoder->usr, encoder->io_now);
- }
- ASSERT(encoder->usr, encoder->io_now < encoder->io_end);
- return *(encoder->io_now++);
-}
-
-static INLINE uint32_t decode_32(Encoder *encoder)
-{
- uint32_t word = 0;
- word |= decode(encoder);
- word <<= 8;
- word |= decode(encoder);
- word <<= 8;
- word |= decode(encoder);
- word <<= 8;
- word |= decode(encoder);
- return word;
-}
-
-static INLINE int is_io_to_decode_end(Encoder *encoder)
-{
- if (encoder->io_now != encoder->io_end) {
- return FALSE;
- } else {
- int num_io_bytes = more_io_bytes(encoder); //disable inline optimizations
- return (num_io_bytes <= 0);
- }
-}
-
-/*******************************************************************
-* intialization and finalization of lz
-********************************************************************/
-static int init_encoder(Encoder *encoder, LzUsrContext *usr)
-{
- encoder->usr = usr;
- encoder->free_image_segs = NULL;
- encoder->head_image_segs = NULL;
- encoder->tail_image_segs = NULL;
- return TRUE;
-}
-
-LzContext *lz_create(LzUsrContext *usr)
-{
- Encoder *encoder;
-
- if (!usr || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
- !usr->free || !usr->more_space || !usr->more_lines) {
- return NULL;
- }
-
- if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
- return NULL;
- }
-
- if (!init_encoder(encoder, usr)) {
- usr->free(usr, encoder);
- return NULL;
- }
- return (LzContext *)encoder;
-}
-
-void lz_destroy(LzContext *lz)
-{
- Encoder *encoder = (Encoder *)lz;
-
- if (!lz) {
- return;
- }
-
- if (encoder->head_image_segs) {
- encoder->usr->error(encoder->usr, "%s: used_image_segments not empty\n", __FUNCTION__);
- lz_reset_image_seg(encoder);
- }
- lz_dealloc_free_segments(encoder);
-
- encoder->usr->free(encoder->usr, encoder);
-}
-
-/*******************************************************************
-* encoding and decoding the image
-********************************************************************/
-/*
- * Give hints to the compiler for branch prediction optimization.
- */
-#if defined(__GNUC__) && (__GNUC__ > 2)
-#define LZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
-#define LZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
-#else
-#define LZ_EXPECT_CONDITIONAL(c) (c)
-#define LZ_UNEXPECT_CONDITIONAL(c) (c)
-#endif
-
-
-#ifdef __GNUC__
-#define ATTR_PACKED __attribute__ ((__packed__))
-#else
-#define ATTR_PACKED
-#pragma pack(push)
-#pragma pack(1)
-#endif
-
-
-/* the palette images will be treated as one byte pixels. Their width should be transformed
- accordingly.
-*/
-typedef struct ATTR_PACKED one_byte_pixel_t {
- uint8_t a;
-} one_byte_pixel_t;
-
-typedef struct ATTR_PACKED rgb32_pixel_t {
- uint8_t b;
- uint8_t g;
- uint8_t r;
- uint8_t pad;
-} rgb32_pixel_t;
-
-typedef struct ATTR_PACKED rgb24_pixel_t {
- uint8_t b;
- uint8_t g;
- uint8_t r;
-} rgb24_pixel_t;
-
-typedef uint16_t rgb16_pixel_t;
-
-#ifndef __GNUC__
-#pragma pack(pop)
-#endif
-
-#undef ATTR_PACKED
-
-
-#define MAX_COPY 32
-#define MAX_LEN 264 /* 256 + 8 */
-#define BOUND_OFFSET 2
-#define LIMIT_OFFSET 6
-#define MIN_FILE_SIZE 4
-#define COMP_LEVEL_SIZE_LIMIT 65536
-
-// TODO: implemented lz2. should lz1 be an option (no RLE + distance limitation of MAX_DISTANCE)
-// TODO: I think MAX_FARDISTANCE can be changed easily to 2^29
-// (and maybe even more when pixel > byte).
-// i.e. we can support 512M Bytes/Pixels distance instead of only ~68K.
-#define MAX_DISTANCE 8191 // 2^13
-#define MAX_FARDISTANCE (65535 + MAX_DISTANCE - 1) // ~2^16+2^13
-
-
-#define LZ_PLT
-#include "lz_compress_tmpl.c"
-#define LZ_PLT
-#include "lz_decompress_tmpl.c"
-
-#define LZ_PLT
-#define PLT8
-#define TO_RGB32
-#include "lz_decompress_tmpl.c"
-
-#define LZ_PLT
-#define PLT4_BE
-#define TO_RGB32
-#include "lz_decompress_tmpl.c"
-
-#define LZ_PLT
-#define PLT4_LE
-#define TO_RGB32
-#include "lz_decompress_tmpl.c"
-
-#define LZ_PLT
-#define PLT1_BE
-#define TO_RGB32
-#include "lz_decompress_tmpl.c"
-
-#define LZ_PLT
-#define PLT1_LE
-#define TO_RGB32
-#include "lz_decompress_tmpl.c"
-
-
-#define LZ_RGB16
-#include "lz_compress_tmpl.c"
-#define LZ_RGB16
-#include "lz_decompress_tmpl.c"
-#define LZ_RGB16
-#define TO_RGB32
-#include "lz_decompress_tmpl.c"
-
-#define LZ_RGB24
-#include "lz_compress_tmpl.c"
-#define LZ_RGB24
-#include "lz_decompress_tmpl.c"
-
-
-#define LZ_RGB32
-#include "lz_compress_tmpl.c"
-#define LZ_RGB32
-#include "lz_decompress_tmpl.c"
-
-#define LZ_RGB_ALPHA
-#include "lz_compress_tmpl.c"
-#define LZ_RGB_ALPHA
-#include "lz_decompress_tmpl.c"
-
-#undef LZ_UNEXPECT_CONDITIONAL
-#undef LZ_EXPECT_CONDITIONAL
-
-int lz_encode(LzContext *lz, LzImageType type, int width, int height, int top_down,
- uint8_t *lines, unsigned int num_lines, int stride,
- uint8_t *io_ptr, unsigned int num_io_bytes)
-{
- Encoder *encoder = (Encoder *)lz;
- uint8_t *io_ptr_end = io_ptr + num_io_bytes;
-
- encoder->type = type;
- encoder->width = width;
- encoder->height = height;
- encoder->stride = stride;
-
- if (IS_IMAGE_TYPE_PLT[encoder->type]) {
- if (encoder->stride > (width / PLT_PIXELS_PER_BYTE[encoder->type])) {
- if (((width % PLT_PIXELS_PER_BYTE[encoder->type]) == 0) || (
- (encoder->stride - (width / PLT_PIXELS_PER_BYTE[encoder->type])) > 1)) {
- encoder->usr->error(encoder->usr, "stride overflows (plt)\n");
- }
- }
- } else {
- if (encoder->stride != width * RGB_BYTES_PER_PIXEL[encoder->type]) {
- encoder->usr->error(encoder->usr, "stride != width*bytes_per_pixel (rgb)\n");
- }
- }
-
- // assign the output buffer
- if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
- encoder->usr->error(encoder->usr, "lz encoder io reset failed\n");
- }
-
- // first read the list of the image segments
- if (!lz_read_image_segments(encoder, lines, num_lines)) {
- encoder->usr->error(encoder->usr, "lz encoder reading image segments failed\n");
- }
-
- encode_32(encoder, LZ_MAGIC);
- encode_32(encoder, LZ_VERSION);
- encode_32(encoder, type);
- encode_32(encoder, width);
- encode_32(encoder, height);
- encode_32(encoder, stride);
- encode_32(encoder, top_down); // TODO: maybe compress type and top_down to one byte
-
- switch (encoder->type) {
- case LZ_IMAGE_TYPE_PLT1_BE:
- case LZ_IMAGE_TYPE_PLT1_LE:
- case LZ_IMAGE_TYPE_PLT4_BE:
- case LZ_IMAGE_TYPE_PLT4_LE:
- case LZ_IMAGE_TYPE_PLT8:
- lz_plt_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGB16:
- lz_rgb16_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGB24:
- lz_rgb24_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGB32:
- lz_rgb32_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_RGBA:
- lz_rgb32_compress(encoder);
- lz_rgb_alpha_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_XXXA:
- lz_rgb_alpha_compress(encoder);
- break;
- case LZ_IMAGE_TYPE_INVALID:
- default:
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
-
- // move all the used segments to the free ones
- lz_reset_image_seg(encoder);
-
- encoder->io_bytes_count -= (encoder->io_end - encoder->io_now);
-
- return encoder->io_bytes_count;
-}
-
-/*
- initialize and read lz magic
-*/
-void lz_decode_begin(LzContext *lz, uint8_t *io_ptr, unsigned int num_io_bytes,
- LzImageType *out_type, int *out_width, int *out_height,
- int *out_n_pixels, int *out_top_down, const SpicePalette *palette)
-{
- Encoder *encoder = (Encoder *)lz;
- uint8_t *io_ptr_end = io_ptr + num_io_bytes;
- uint32_t magic;
- uint32_t version;
-
- if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
- encoder->usr->error(encoder->usr, "io reset failed");
- }
-
- magic = decode_32(encoder);
- if (magic != LZ_MAGIC) {
- encoder->usr->error(encoder->usr, "bad magic\n");
- }
-
- version = decode_32(encoder);
- if (version != LZ_VERSION) {
- encoder->usr->error(encoder->usr, "bad version\n");
- }
-
- encoder->type = (LzImageType)decode_32(encoder);
- encoder->width = decode_32(encoder);
- encoder->height = decode_32(encoder);
- encoder->stride = decode_32(encoder);
- *out_top_down = decode_32(encoder);
-
- *out_width = encoder->width;
- *out_height = encoder->height;
-// *out_stride = encoder->stride;
- *out_type = encoder->type;
-
- // TODO: maybe instead of stride we can encode out_n_pixels
- // (if stride is not necessary in decoding).
- if (IS_IMAGE_TYPE_PLT[encoder->type]) {
- encoder->palette = palette;
- *out_n_pixels = encoder->stride * PLT_PIXELS_PER_BYTE[encoder->type] * encoder->height;
- } else {
- *out_n_pixels = encoder->width * encoder->height;
- }
-}
-
-void lz_decode(LzContext *lz, LzImageType to_type, uint8_t *buf)
-{
- Encoder *encoder = (Encoder *)lz;
- size_t out_size = 0;
- size_t alpha_size = 0;
- size_t size = 0;
- if (IS_IMAGE_TYPE_PLT[encoder->type]) {
- if (to_type == encoder->type) {
- size = encoder->height * encoder->stride;
- out_size = lz_plt_decompress(encoder, (one_byte_pixel_t *)buf, size);
- } else if (to_type == LZ_IMAGE_TYPE_RGB32) {
- size = encoder->height * encoder->stride * PLT_PIXELS_PER_BYTE[encoder->type];
- if (!encoder->palette) {
- encoder->usr->error(encoder->usr,
- "a palette is missing (for bpp to rgb decoding)\n");
- }
- switch (encoder->type) {
- case LZ_IMAGE_TYPE_PLT1_BE:
- out_size = lz_plt1_be_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- break;
- case LZ_IMAGE_TYPE_PLT1_LE:
- out_size = lz_plt1_le_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- break;
- case LZ_IMAGE_TYPE_PLT4_BE:
- out_size = lz_plt4_be_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- break;
- case LZ_IMAGE_TYPE_PLT4_LE:
- out_size = lz_plt4_le_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- break;
- case LZ_IMAGE_TYPE_PLT8:
- out_size = lz_plt8_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- break;
- case LZ_IMAGE_TYPE_RGB16:
- case LZ_IMAGE_TYPE_RGB24:
- case LZ_IMAGE_TYPE_RGB32:
- case LZ_IMAGE_TYPE_RGBA:
- case LZ_IMAGE_TYPE_XXXA:
- case LZ_IMAGE_TYPE_INVALID:
- default:
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
- } else {
- encoder->usr->error(encoder->usr, "unsupported output format\n");
- }
- } else {
- size = encoder->height * encoder->width;
- switch (encoder->type) {
- case LZ_IMAGE_TYPE_RGB16:
- if (encoder->type == to_type) {
- out_size = lz_rgb16_decompress(encoder, (rgb16_pixel_t *)buf, size);
- } else if (to_type == LZ_IMAGE_TYPE_RGB32) {
- out_size = lz_rgb16_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- } else {
- encoder->usr->error(encoder->usr, "unsupported output format\n");
- }
- break;
- case LZ_IMAGE_TYPE_RGB24:
- if (encoder->type == to_type) {
- out_size = lz_rgb24_decompress(encoder, (rgb24_pixel_t *)buf, size);
- } else if (to_type == LZ_IMAGE_TYPE_RGB32) {
- out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- } else {
- encoder->usr->error(encoder->usr, "unsupported output format\n");
- }
- break;
- case LZ_IMAGE_TYPE_RGB32:
- if (encoder->type == to_type) {
- out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- } else {
- encoder->usr->error(encoder->usr, "unsupported output format\n");
- }
- break;
- case LZ_IMAGE_TYPE_RGBA:
- if (encoder->type == to_type) {
- out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
- alpha_size = lz_rgb_alpha_decompress(encoder, (rgb32_pixel_t *)buf, size);
- ASSERT(encoder->usr, alpha_size == size);
- } else {
- encoder->usr->error(encoder->usr, "unsupported output format\n");
- }
- break;
- case LZ_IMAGE_TYPE_XXXA:
- if (encoder->type == to_type) {
- alpha_size = lz_rgb_alpha_decompress(encoder, (rgb32_pixel_t *)buf, size);
- out_size = alpha_size;
- } else {
- encoder->usr->error(encoder->usr, "unsupported output format\n");
- }
- break;
- 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:
- case LZ_IMAGE_TYPE_INVALID:
- default:
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
- }
-
- ASSERT(encoder->usr, is_io_to_decode_end(encoder));
- ASSERT(encoder->usr, out_size == size);
-
- if (out_size != size) {
- encoder->usr->error(encoder->usr, "bad decode size\n");
- }
-}
diff --git a/common/lz.h b/common/lz.h
deleted file mode 100644
index 472e34d..0000000
--- a/common/lz.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- dictionary compression for images based on fastlz (http://www.fastlz.org/)
- (Distributed under MIT license).
-*/
-#ifndef __LZ_H
-#define __LZ_H
-
-#include "lz_common.h"
-#include "lz_config.h"
-#include "draw.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void *LzContext;
-
-typedef struct LzUsrContext LzUsrContext;
-struct LzUsrContext {
- void (*error)(LzUsrContext *usr, const char *fmt, ...);
- void (*warn)(LzUsrContext *usr, const char *fmt, ...);
- void (*info)(LzUsrContext *usr, const char *fmt, ...);
- void *(*malloc)(LzUsrContext *usr, int size);
- void (*free)(LzUsrContext *usr, void *ptr);
- int (*more_space)(LzUsrContext *usr, uint8_t **io_ptr); // get the next chunk of the
- // compressed buffer. return
- // number of bytes in the chunk.
- int (*more_lines)(LzUsrContext *usr, uint8_t **lines); // get the next chunk of the
- // original image. If the image
- // is down to top, return it from
- // the last line to the first one
- // (stride should always be
- // positive)
-};
-
-/*
- assumes width is in pixels and stride is in bytes
- return: the number of bytes in the compressed data
-
- TODO : determine size limit for the first segment and each chunk. check validity
- of the segment or go to literal copy.
- TODO : currently support only rgb images in which width*bytes_per_pixel = stride OR
- palette images in which stride equals the min number of bytes to
- hold a line. stride is not necessary for now. just for sanity check.
- stride should be > 0
-*/
-int lz_encode(LzContext *lz, LzImageType type, int width, int height, int top_down,
- uint8_t *lines, unsigned int num_lines, int stride,
- uint8_t *io_ptr, unsigned int num_io_bytes);
-
-/*
- prepare encoder and read lz magic.
- out_n_pixels number of compressed pixels. May differ from Width*height in plt1/4.
- Use it for allocation the decompressed buffer.
-
-*/
-void lz_decode_begin(LzContext *lz, uint8_t *io_ptr, unsigned int num_io_bytes,
- LzImageType *out_type, int *out_width, int *out_height,
- int *out_n_pixels, int *out_top_down, const SpicePalette *palette);
-
-/*
- to_type = the image output type.
- We assume the buffer is consecutive. i.e. width = stride
-
- Important: if the image is plt1/4 and to_type is rgb32, the image
- will decompressed including the last bits in each line. This means buffer should be
- larger than width*height if needed and you should use stride to fix it.
- Note: If the image is down to top, set the stride in the sw surface to negative.
- use alloc_lz_image_surface create the surface.
-*/
-void lz_decode(LzContext *lz, LzImageType to_type, uint8_t *buf);
-
-LzContext *lz_create(LzUsrContext *usr);
-
-void lz_destroy(LzContext *lz);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __LZ_H
diff --git a/common/lz_common.h b/common/lz_common.h
deleted file mode 100644
index 4156cff..0000000
--- a/common/lz_common.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
-
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-/*common header for encoder and decoder*/
-
-#ifndef _LZ_COMMON_H
-#define _LZ_COMMON_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//#define DEBUG
-
-/* change the max window size will require change in the encoding format*/
-#define LZ_MAX_WINDOW_SIZE (1 << 25)
-#define MAX_COPY 32
-
-typedef enum {
- LZ_IMAGE_TYPE_INVALID,
- LZ_IMAGE_TYPE_PLT1_LE,
- LZ_IMAGE_TYPE_PLT1_BE, // PLT stands for palette
- LZ_IMAGE_TYPE_PLT4_LE,
- LZ_IMAGE_TYPE_PLT4_BE,
- LZ_IMAGE_TYPE_PLT8,
- LZ_IMAGE_TYPE_RGB16,
- LZ_IMAGE_TYPE_RGB24,
- LZ_IMAGE_TYPE_RGB32,
- LZ_IMAGE_TYPE_RGBA,
- LZ_IMAGE_TYPE_XXXA
-} LzImageType;
-
-#define LZ_IMAGE_TYPE_MASK 0x0f
-#define LZ_IMAGE_TYPE_LOG 4 // number of bits required for coding the image type
-
-/* access to the arrays is based on the image types */
-static const int IS_IMAGE_TYPE_PLT[] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0};
-static const int IS_IMAGE_TYPE_RGB[] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};
-static const int PLT_PIXELS_PER_BYTE[] = {0, 8, 8, 2, 2, 1};
-static const int RGB_BYTES_PER_PIXEL[] = {0, 1, 1, 1, 1, 1, 2, 3, 4, 4, 4};
-
-
-#define LZ_MAGIC (*(uint32_t *)"LZ ")
-#define LZ_VERSION_MAJOR 1U
-#define LZ_VERSION_MINOR 1U
-#define LZ_VERSION ((LZ_VERSION_MAJOR << 16) | (LZ_VERSION_MINOR & 0xffff))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _LZ_COMMON_H
diff --git a/common/lz_compress_tmpl.c b/common/lz_compress_tmpl.c
deleted file mode 100644
index 6db5387..0000000
--- a/common/lz_compress_tmpl.c
+++ /dev/null
@@ -1,529 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
-
- Copyright (C) 2009 Red Hat, Inc. and/or its affiliates.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- This file incorporates work covered by the following copyright and
- permission notice:
- Copyright (C) 2007 Ariya Hidayat (ariya at kde.org)
- Copyright (C) 2006 Ariya Hidayat (ariya at kde.org)
- Copyright (C) 2005 Ariya Hidayat (ariya at kde.org)
-
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use, copy,
- modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
-
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#define DJB2_START 5381;
-#define DJB2_HASH(hash, c) (hash = ((hash << 5) + hash) ^ (c)) //|{hash = ((hash << 5) + hash) + c;}
-
-/*
- For each pixel type the following macros are defined:
- PIXEL : input type
- FNAME(name)
- ENCODE_PIXEL(encoder, pixel) : writing a pixel to the compressed buffer (byte by byte)
- SAME_PIXEL(pix1, pix2) : comparing two pixels
- HASH_FUNC(value, pix_ptr) : hash func of 3 consecutive pixels
-*/
-
-#ifdef LZ_PLT
-#define PIXEL one_byte_pixel_t
-#define FNAME(name) lz_plt_##name
-#define ENCODE_PIXEL(e, pix) encode(e, (pix).a) // gets the pixel and write only the needed bytes
- // from the pixel
-#define SAME_PIXEL(pix1, pix2) ((pix1).a == (pix2).a)
-#define HASH_FUNC(v, p) { \
- v = DJB2_START; \
- DJB2_HASH(v, p[0].a); \
- DJB2_HASH(v, p[1].a); \
- DJB2_HASH(v, p[2].a); \
- v &= HASH_MASK; \
- }
-#endif
-
-#ifdef LZ_RGB_ALPHA
-//#undef LZ_RGB_ALPHA
-#define PIXEL rgb32_pixel_t
-#define FNAME(name) lz_rgb_alpha_##name
-#define ENCODE_PIXEL(e, pix) {encode(e, (pix).pad);}
-#define SAME_PIXEL(pix1, pix2) ((pix1).pad == (pix2).pad)
-#define HASH_FUNC(v, p) { \
- v = DJB2_START; \
- DJB2_HASH(v, p[0].pad); \
- DJB2_HASH(v, p[1].pad); \
- DJB2_HASH(v, p[2].pad); \
- v &= HASH_MASK; \
- }
-#endif
-
-
-#ifdef LZ_RGB16
-#define PIXEL rgb16_pixel_t
-#define FNAME(name) lz_rgb16_##name
-#define GET_r(pix) (((pix) >> 10) & 0x1f)
-#define GET_g(pix) (((pix) >> 5) & 0x1f)
-#define GET_b(pix) ((pix) & 0x1f)
-#define ENCODE_PIXEL(e, pix) {encode(e, (pix) >> 8); encode(e, (pix) & 0xff);}
-
-#define HASH_FUNC(v, p) { \
- v = DJB2_START; \
- DJB2_HASH(v, p[0] & (0x00ff)); \
- DJB2_HASH(v, (p[0] >> 8) & (0x007f)); \
- DJB2_HASH(v, p[1]&(0x00ff)); \
- DJB2_HASH(v, (p[1] >> 8) & (0x007f)); \
- DJB2_HASH(v, p[2] & (0x00ff)); \
- DJB2_HASH(v, (p[2] >> 8) & (0x007f)); \
- v &= HASH_MASK; \
-}
-#endif
-
-#ifdef LZ_RGB24
-#define PIXEL rgb24_pixel_t
-#define FNAME(name) lz_rgb24_##name
-#define ENCODE_PIXEL(e, pix) {encode(e, (pix).b); encode(e, (pix).g); encode(e, (pix).r);}
-#endif
-
-#ifdef LZ_RGB32
-#define PIXEL rgb32_pixel_t
-#define FNAME(name) lz_rgb32_##name
-#define ENCODE_PIXEL(e, pix) {encode(e, (pix).b); encode(e, (pix).g); encode(e, (pix).r);}
-#endif
-
-
-#if defined(LZ_RGB24) || defined(LZ_RGB32)
-#define GET_r(pix) ((pix).r)
-#define GET_g(pix) ((pix).g)
-#define GET_b(pix) ((pix).b)
-#define HASH_FUNC(v, p) { \
- v = DJB2_START; \
- DJB2_HASH(v, p[0].r); \
- DJB2_HASH(v, p[0].g); \
- DJB2_HASH(v, p[0].b); \
- DJB2_HASH(v, p[1].r); \
- DJB2_HASH(v, p[1].g); \
- DJB2_HASH(v, p[1].b); \
- DJB2_HASH(v, p[2].r); \
- DJB2_HASH(v, p[2].g); \
- DJB2_HASH(v, p[2].b); \
- v &= HASH_MASK; \
- }
-#endif
-
-#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
-#define SAME_PIXEL(p1, p2) (GET_r(p1) == GET_r(p2) && GET_g(p1) == GET_g(p2) && \
- GET_b(p1) == GET_b(p2))
-
-#endif
-
-#define PIXEL_ID(pix_ptr, seg_ptr) (pix_ptr - ((PIXEL *)seg_ptr->lines) + seg_ptr->size_delta)
-
-// when encoding, the ref can be in previous segment, and we should check that it doesn't
-// exceeds its bounds.
-// TODO: optimization: when only one chunk exists or when the reference is in the same segment,
-// don't make checks if we reach end of segments
-// TODO: optimize to continue match between segments?
-// TODO: check hash function
-// TODO: check times
-
-/* compresses one segment starting from 'from'.*/
-static void FNAME(compress_seg)(Encoder *encoder, LzImageSegment *seg, PIXEL *from, int copied)
-{
- const PIXEL *ip = from;
- const PIXEL *ip_bound = (PIXEL *)(seg->lines_end) - BOUND_OFFSET;
- const PIXEL *ip_limit = (PIXEL *)(seg->lines_end) - LIMIT_OFFSET;
- HashEntry *hslot;
- int hval;
- int copy = copied;
-
- if (copy == 0) {
- encode_copy_count(encoder, MAX_COPY - 1);
- }
-
-
- while (LZ_EXPECT_CONDITIONAL(ip < ip_limit)) { // TODO: maybe change ip_limit and enabling
- // moving to the next seg
- const PIXEL *ref;
- const PIXEL *ref_limit;
- size_t distance;
-
- /* minimum match length */
-#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
- size_t len = 3;
-#elif defined(LZ_RGB16)
- size_t len = 2;
-#else
- size_t len = 1;
-#endif
- /* comparison starting-point */
- const PIXEL *anchor = ip;
-
-
-
- // TODO: RLE without checking if not first byte.
- // TODO: optimize comparisons
-
- /* check for a run */ // TODO for RGB we can use less pixels
- if (LZ_EXPECT_CONDITIONAL(ip > (PIXEL *)(seg->lines))) {
- if (SAME_PIXEL(ip[-1], ip[0]) && SAME_PIXEL(ip[0], ip[1]) && SAME_PIXEL(ip[1], ip[2])) {
- distance = 1;
- ip += 3;
- ref = anchor + 2;
- ref_limit = (PIXEL *)(seg->lines_end);
-#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
- len = 3;
-#endif
- goto match;
- }
- }
-
- /* find potential match */
- HASH_FUNC(hval, ip);
- hslot = encoder->htab + hval;
- ref = (PIXEL *)(hslot->ref);
- ref_limit = (PIXEL *)(hslot->image_seg->lines_end);
-
- /* calculate distance to the match */
- distance = PIXEL_ID(anchor, seg) - PIXEL_ID(ref, hslot->image_seg);
-
- /* update hash table */
- hslot->image_seg = seg;
- hslot->ref = (uint8_t *)anchor;
-
- /* is this a match? check the first 3 pixels */
- if (distance == 0 || (distance >= MAX_FARDISTANCE)) {
- goto literal;
- }
- /* check if the hval key identical*/
- // no need to check ref limit here because the word size in the htab is 3 pixels
- if (!SAME_PIXEL(*ref, *ip)) {
- ref++;
- ip++;
- goto literal;
- }
- ref++;
- ip++;
-
- /* minimum match length for rgb16 is 2 and for plt and alpha is 3 */
-#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA) || defined(LZ_RGB16)
- if (!SAME_PIXEL(*ref, *ip)) {
- ref++;
- ip++;
- goto literal;
- }
- ref++;
- ip++;
-#endif
-
-#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
- if (!SAME_PIXEL(*ref, *ip)) {
- ref++;
- ip++;
- goto literal;
- }
- ref++;
- ip++;
-#endif
- /* far, needs at least 5-byte match */
- if (distance >= MAX_DISTANCE) {
-#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
- if (ref >= (ref_limit - 1)) {
- goto literal;
- }
-#else
- if (ref > (ref_limit - 1)) {
- goto literal;
- }
-#endif
- if (!SAME_PIXEL(*ref, *ip)) {
- ref++;
- ip++;
- goto literal;
- }
- ref++;
- ip++;
- len++;
-#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
- if (!SAME_PIXEL(*ref, *ip)) {
- ref++;
- ip++;
- goto literal;
- }
- ref++;
- ip++;
- len++;
-#endif
- }
-match: // RLE or dictionary (both are encoded by distance from ref (-1) and length)
-
- /* distance is biased */
- distance--;
-
- // ip is located now at the position of the second mismatch.
- // later it will be subtracted by 3
-
- if (!distance) {
- /* zero distance means a run */
- PIXEL x = *ref;
- while ((ip < ip_bound) && (ref < ref_limit)) { // TODO: maybe separate a run from
- // the same seg or from different
- // ones in order to spare
- // ref < ref_limit
- if (!SAME_PIXEL(*ref, x)) {
- ref++;
- break;
- } else {
- ref++;
- ip++;
- }
- }
- } else {
- // TODO: maybe separate a run from the same seg or from different ones in order
- // to spare ref < ref_limit and that way we can also perform 8 calls of
- // (ref++ != ip++) outside a loop
- for (;;) {
- while ((ip < ip_bound) && (ref < ref_limit)) {
- if (!SAME_PIXEL(*ref, *ip)) {
- ref++;
- ip++;
- break;
- } else {
- ref++;
- ip++;
- }
- }
- break;
- }
- }
-
- /* if we have copied something, adjust the copy count */
- if (copy) {
- /* copy is biased, '0' means 1 byte copy */
- update_copy_count(encoder, copy - 1);
- } else {
- /* back, to overwrite the copy count */
- compress_output_prev(encoder);
- }
-
- /* reset literal counter */
- copy = 0;
-
- /* length is biased, '1' means a match of 3 pixels for PLT and alpha*/
- /* for RGB 16 1 means 2 */
- /* for RGB24/32 1 means 1...*/
- ip -= 3;
- len = ip - anchor;
-#if defined(LZ_RGB16)
- len++;
-#elif defined(LZ_RGB24) || defined(LZ_RGB32)
- len += 2;
-#endif
- /* encode the match (like fastlz level 2)*/
- if (distance < MAX_DISTANCE) { // MAX_DISTANCE is 2^13 - 1
- // when copy is performed, the byte that holds the copy count is smaller than 32.
- // When there is a reference, the first byte is always larger then 32
-
- // 3 bits = length, 5 bits = 5 MSB of distance, 8 bits = 8 LSB of distance
- if (len < 7) {
- encode(encoder, (uint8_t)((len << 5) + (distance >> 8)));
- encode(encoder, (uint8_t)(distance & 255));
- } else { // more than 3 bits are needed for length
- // 3 bits 7, 5 bits = 5 MSB of distance, next bytes are 255 till we
- // receive a smaller number, last byte = 8 LSB of distance
- encode(encoder, (uint8_t)((7 << 5) + (distance >> 8)));
- for (len -= 7; len >= 255; len -= 255) {
- encode(encoder, 255);
- }
- encode(encoder, (uint8_t)len);
- encode(encoder, (uint8_t)(distance & 255));
- }
- } else {
- /* far away */
- if (len < 7) { // the max_far_distance is ~2^16+2^13 so two more bytes are needed
- // 3 bits = length, 5 bits = 5 MSB of MAX_DISTANCE, 8 bits = 8 LSB of MAX_DISTANCE,
- // 8 bits = 8 MSB distance-MAX_distance (smaller than 2^16),8 bits=8 LSB of
- // distance-MAX_distance
- distance -= MAX_DISTANCE;
- encode(encoder, (uint8_t)((len << 5) + 31));
- encode(encoder, (uint8_t)255);
- encode(encoder, (uint8_t)(distance >> 8));
- encode(encoder, (uint8_t)(distance & 255));
- } else {
- // same as before, but the first byte is followed by the left overs of len
- distance -= MAX_DISTANCE;
- encode(encoder, (uint8_t)((7 << 5) + 31));
- for (len -= 7; len >= 255; len -= 255) {
- encode(encoder, 255);
- }
- encode(encoder, (uint8_t)len);
- encode(encoder, 255);
- encode(encoder, (uint8_t)(distance >> 8));
- encode(encoder, (uint8_t)(distance & 255));
- }
- }
-
- /* update the hash at match boundary */
-#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
- if (ip > anchor) {
-#endif
- HASH_FUNC(hval, ip);
- encoder->htab[hval].ref = (uint8_t *)ip;
- ip++;
- encoder->htab[hval].image_seg = seg;
-#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
- } else {ip++;
- }
-#endif
-#if defined(LZ_RGB24) || defined(LZ_RGB32)
- if (ip > anchor) {
-#endif
- HASH_FUNC(hval, ip);
- encoder->htab[hval].ref = (uint8_t *)ip;
- ip++;
- encoder->htab[hval].image_seg = seg;
-#if defined(LZ_RGB24) || defined(LZ_RGB32)
- } else {ip++;
- }
-#endif
- /* assuming literal copy */
- encode_copy_count(encoder, MAX_COPY - 1);
- continue;
-
-literal:
- ENCODE_PIXEL(encoder, *anchor);
- anchor++;
- ip = anchor;
- copy++;
-
- if (LZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY)) {
- copy = 0;
- encode_copy_count(encoder, MAX_COPY - 1);
- }
- } // END LOOP (ip < ip_limit)
-
-
- /* left-over as literal copy */
- ip_bound++;
- while (ip <= ip_bound) {
- ENCODE_PIXEL(encoder, *ip);
- ip++;
- copy++;
- if (copy == MAX_COPY) {
- copy = 0;
- encode_copy_count(encoder, MAX_COPY - 1);
- }
- }
-
- /* if we have copied something, adjust the copy length */
- if (copy) {
- update_copy_count(encoder, copy - 1);
- } else {
- compress_output_prev(encoder); // in case we created a new buffer for copy, check that
- // red_worker could handle size that do not contain the
- // ne buffer
- }
-}
-
-
-/* initializes the hash table. if the file is very small, copies it.
- copies the first two pixels of the first segment, and sends the segments
- one by one to compress_seg.
- the number of bytes compressed are stored inside encoder.
- */
-static void FNAME(compress)(Encoder *encoder)
-{
- LzImageSegment *cur_seg = encoder->head_image_segs;
- HashEntry *hslot;
- PIXEL *ip;
-
- // fetch the first image segment that is not too small
- while (cur_seg && ((((PIXEL *)cur_seg->lines_end) - ((PIXEL *)cur_seg->lines)) < 4)) {
- // coping the segment
- if (cur_seg->lines != cur_seg->lines_end) {
- ip = (PIXEL *)cur_seg->lines;
- // Note: we assume MAX_COPY > 3
- encode_copy_count(encoder, (uint8_t)(
- (((PIXEL *)cur_seg->lines_end) - ((PIXEL *)cur_seg->lines)) - 1));
- while (ip < (PIXEL *)cur_seg->lines_end) {
- ENCODE_PIXEL(encoder, *ip);
- ip++;
- }
- }
- cur_seg = cur_seg->next;
- }
-
- if (!cur_seg) {
- return;
- }
-
- ip = (PIXEL *)cur_seg->lines;
-
- /* initialize hash table */
- for (hslot = encoder->htab; hslot < encoder->htab + HASH_SIZE; hslot++) {
- hslot->ref = (uint8_t*)ip;
- hslot->image_seg = cur_seg;
- }
-
- encode_copy_count(encoder, MAX_COPY - 1);
- ENCODE_PIXEL(encoder, *ip);
- ip++;
- ENCODE_PIXEL(encoder, *ip);
- ip++;
-
- // compressing the first segment
- FNAME(compress_seg)(encoder, cur_seg, ip, 2);
-
- // compressing the next segments
- for (cur_seg = cur_seg->next; cur_seg; cur_seg = cur_seg->next) {
- FNAME(compress_seg)(encoder, cur_seg, (PIXEL *)cur_seg->lines, 0);
- }
-}
-
-#undef FNAME
-#undef PIXEL_ID
-#undef PIXEL
-#undef ENCODE_PIXEL
-#undef SAME_PIXEL
-#undef LZ_READU16
-#undef HASH_FUNC
-#undef BYTES_TO_16
-#undef HASH_FUNC_16
-#undef GET_r
-#undef GET_g
-#undef GET_b
-#undef GET_CODE
-#undef LZ_PLT
-#undef LZ_RGB_ALPHA
-#undef LZ_RGB16
-#undef LZ_RGB24
-#undef LZ_RGB32
-#undef HASH_FUNC2
diff --git a/common/lz_config.h b/common/lz_config.h
deleted file mode 100644
index d8675a8..0000000
--- a/common/lz_config.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
-
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#ifndef __LZ_CONFIG_H
-#define __LZ_CONFIG_H
-
-#include <spice/types.h>
-#include <spice/macros.h>
-
-#ifdef __GNUC__
-#include <string.h>
-#else
-#ifdef QXLDD
-#include <windef.h>
-#include "os_dep.h"
-#else
-#include <stddef.h>
-#include <string.h>
-#endif // QXLDD
-#endif //__GNUC__
-
-#endif //__LZ_CONFIG_H
diff --git a/common/lz_decompress_tmpl.c b/common/lz_decompress_tmpl.c
deleted file mode 100644
index b0cbb2a..0000000
--- a/common/lz_decompress_tmpl.c
+++ /dev/null
@@ -1,326 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
-
- Copyright (C) 2009 Red Hat, Inc. and/or its affiliates.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-
- This file incorporates work covered by the following copyright and
- permission notice:
- Copyright (C) 2007 Ariya Hidayat (ariya at kde.org)
- Copyright (C) 2006 Ariya Hidayat (ariya at kde.org)
- Copyright (C) 2005 Ariya Hidayat (ariya at kde.org)
-
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use, copy,
- modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
-
-*/
-
-// External defines: PLT, RGBX/PLTXX/ALPHA, TO_RGB32.
-// If PLT4/1 and TO_RGB32 are defined, we need CAST_PLT_DISTANCE (because then the number of
-// pixels differ from the units used in the compression)
-
-/*
- For each output pixel type the following macros are defined:
- OUT_PIXEL - the output pixel type
- COPY_PIXEL(p, out) - assigns the pixel to the place pointed by out and increases
- out. Used in RLE. Need special handling because in alpha we
- copy only the pad byte.
- COPY_REF_PIXEL(ref, out) - copies the pixel pointed by ref to the pixel pointed by out.
- Increases ref and out.
- COPY_COMP_PIXEL(encoder, out) - copies pixel from the compressed buffer to the decompressed
- buffer. Increases out.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#if !defined(LZ_RGB_ALPHA)
-#define COPY_PIXEL(p, out) (*out++ = p)
-#define COPY_REF_PIXEL(ref, out) (*out++ = *ref++)
-#endif
-
-
-// decompressing plt to plt
-#ifdef LZ_PLT
-#ifndef TO_RGB32
-#define OUT_PIXEL one_byte_pixel_t
-#define FNAME(name) lz_plt_##name
-#define COPY_COMP_PIXEL(encoder, out) {out->a = decode(encoder); out++;}
-#else // TO_RGB32
-#define OUT_PIXEL rgb32_pixel_t
-#define COPY_PLT_ENTRY(ent, out) { \
- (out)->b = ent; \
- (out)->g = (ent >> 8); \
- (out)->r = (ent >> 16); \
- (out)->pad = 0; \
-}
-#ifdef PLT8
-#define FNAME(name) lz_plt8_to_rgb32_##name
-#define COPY_COMP_PIXEL(encoder, out) { \
- uint32_t rgb = encoder->palette->ents[decode(encoder)]; \
- COPY_PLT_ENTRY(rgb, out); \
- out++;}
-#elif defined(PLT4_BE)
-#define FNAME(name) lz_plt4_be_to_rgb32_##name
-#define COPY_COMP_PIXEL(encoder, out){ \
- uint8_t byte = decode(encoder); \
- uint32_t rgb = encoder->palette->ents[((byte >> 4) & 0x0f) % (encoder->palette->num_ents)]; \
- COPY_PLT_ENTRY(rgb, out); \
- out++; \
- rgb = encoder->palette->ents[(byte & 0x0f) % (encoder->palette->num_ents)]; \
- COPY_PLT_ENTRY(rgb, out); \
- out++; \
-}
-#define CAST_PLT_DISTANCE(dist) (dist*2)
-#elif defined(PLT4_LE)
-#define FNAME(name) lz_plt4_le_to_rgb32_##name
-#define COPY_COMP_PIXEL(encoder, out){ \
- uint8_t byte = decode(encoder); \
- uint32_t rgb = encoder->palette->ents[(byte & 0x0f) % (encoder->palette->num_ents)]; \
- COPY_PLT_ENTRY(rgb, out); \
- out++; \
- rgb = encoder->palette->ents[((byte >> 4) & 0x0f) % (encoder->palette->num_ents)]; \
- COPY_PLT_ENTRY(rgb, out); \
- out++; \
-}
-#define CAST_PLT_DISTANCE(dist) (dist*2)
-#elif defined(PLT1_BE) // TODO store palette entries for direct access
-#define FNAME(name) lz_plt1_be_to_rgb32_##name
-#define COPY_COMP_PIXEL(encoder, out){ \
- uint8_t byte = decode(encoder); \
- int i; \
- uint32_t fore = encoder->palette->ents[1]; \
- uint32_t back = encoder->palette->ents[0]; \
- for (i = 7; i >= 0; i--) \
- { \
- if ((byte >> i) & 1) { \
- COPY_PLT_ENTRY(fore, out); \
- } else { \
- COPY_PLT_ENTRY(back, out); \
- } \
- out++; \
- } \
-}
-#define CAST_PLT_DISTANCE(dist) (dist*8)
-#elif defined(PLT1_LE)
-#define FNAME(name) lz_plt1_le_to_rgb32_##name
-#define COPY_COMP_PIXEL(encoder, out){ \
- uint8_t byte = decode(encoder); \
- int i; \
- uint32_t fore = encoder->palette->ents[1]; \
- uint32_t back = encoder->palette->ents[0]; \
- for (i = 0; i < 8; i++) \
- { \
- if ((byte >> i) & 1) { \
- COPY_PLT_ENTRY(fore, out); \
- } else { \
- COPY_PLT_ENTRY(back, out); \
- } \
- out++; \
- } \
-}
-#define CAST_PLT_DISTANCE(dist) (dist*8)
-#endif // PLT Type
-#endif // TO_RGB32
-#endif
-
-#ifdef LZ_RGB16
-#ifndef TO_RGB32
-#define OUT_PIXEL rgb16_pixel_t
-#define FNAME(name) lz_rgb16_##name
-#define COPY_COMP_PIXEL(e, out) {*out = ((decode(e) << 8) | decode(e)); out++;}
-#else
-#define OUT_PIXEL rgb32_pixel_t
-#define FNAME(name) lz_rgb16_to_rgb32_##name
-#define COPY_COMP_PIXEL(e, out) { \
- out->r = decode(e); \
- out->b = decode(e); \
- out->g = (((out->r) << 6) | ((out->b) >> 2)) & ~0x07; \
- out->g |= (out->g >> 5); \
- out->r = ((out->r << 1) & ~0x07)| ((out->r >> 4) & 0x07); \
- out->b = (out->b << 3) | ((out->b >> 2) & 0x07); \
- out->pad = 0; \
- out++; \
-}
-#endif
-#endif
-
-#ifdef LZ_RGB24
-#define OUT_PIXEL rgb24_pixel_t
-#define FNAME(name) lz_rgb24_##name
-#define COPY_COMP_PIXEL(e, out) {out->b = decode(e); out->g = decode(e); out->r = decode(e); out++;}
-#endif
-
-#ifdef LZ_RGB32
-#define OUT_PIXEL rgb32_pixel_t
-#define FNAME(name) lz_rgb32_##name
-#define COPY_COMP_PIXEL(e, out) { \
- out->b = decode(e); \
- out->g = decode(e); \
- out->r = decode(e); \
- out->pad = 0; \
- out++; \
-}
-#endif
-
-#ifdef LZ_RGB_ALPHA
-#define OUT_PIXEL rgb32_pixel_t
-#define FNAME(name) lz_rgb_alpha_##name
-#define COPY_PIXEL(p, out) {out->pad = p.pad; out++;}
-#define COPY_REF_PIXEL(ref, out) {out->pad = ref->pad; out++; ref++;}
-#define COPY_COMP_PIXEL(e, out) {out->pad = decode(e); out++;}
-#endif
-
-// return num of bytes in out_buf
-static size_t FNAME(decompress)(Encoder *encoder, OUT_PIXEL *out_buf, int size)
-{
- OUT_PIXEL *op = out_buf;
- OUT_PIXEL *op_limit = out_buf + size;
- uint32_t ctrl = decode(encoder);
- int loop = TRUE;
-
- do {
- const OUT_PIXEL *ref = op;
- uint32_t len = ctrl >> 5;
- uint32_t ofs = (ctrl & 31) << 8; // 5 MSb of distance
-
- if (ctrl >= MAX_COPY) { // reference (dictionary/RLE)
- /* retrieving the reference and the match length */
-
- uint8_t code;
- len--;
- //ref -= ofs;
- if (len == 7 - 1) { // match length is bigger than 7
- do {
- code = decode(encoder);
- len += code;
- } while (code == 255); // remaining of len
- }
- code = decode(encoder);
- ofs += code;
-
- /* match from 16-bit distance */
- if (LZ_UNEXPECT_CONDITIONAL(code == 255)) {
- if (LZ_EXPECT_CONDITIONAL((ofs - code) == (31 << 8))) {
- ofs = decode(encoder) << 8;
- ofs += decode(encoder);
- ofs += MAX_DISTANCE;
- }
- }
-
-#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
- len += 3; // length is biased by 2 + 1 (fixing bias)
-#elif defined(LZ_RGB16)
- len += 2; // length is biased by 1 + 1 (fixing bias)
-#else
- len += 1;
-#endif
- ofs += 1; // offset is biased by 1 (fixing bias)
-
-#if defined(TO_RGB32)
-#if defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || defined(PLT1_LE)
- ofs = CAST_PLT_DISTANCE(ofs);
- len = CAST_PLT_DISTANCE(len);
-#endif
-#endif
- ref -= ofs;
-
- ASSERT(encoder->usr, op + len <= op_limit);
- ASSERT(encoder->usr, ref + len <= op_limit);
- ASSERT(encoder->usr, ref >= out_buf);
-
- // TODO: optimize by not calling loop at least 3 times when not PLT_TO_RGB32 (len is
- // always >=3). in PLT_TO_RGB32 len >= 3*number_of_pixels_per_byte
-
- /* copying the match*/
-
- if (ref == (op - 1)) { // run // TODO: this will never be called in PLT4/1_TO_RGB
- // because the number of pixel copied is larger
- // then one...
- /* optimize copy for a run */
- OUT_PIXEL b = *ref;
- for (; len; --len) {
- COPY_PIXEL(b, op);
- ASSERT(encoder->usr, op <= op_limit);
- }
- } else {
- for (; len; --len) {
- COPY_REF_PIXEL(ref, op);
- ASSERT(encoder->usr, op <= op_limit);
- }
- }
- } else { // copy
- ctrl++; // copy count is biased by 1
-#if defined(TO_RGB32) && (defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || \
- defined(PLT1_LE))
- ASSERT(encoder->usr, op + CAST_PLT_DISTANCE(ctrl) <= op_limit);
-#else
- ASSERT(encoder->usr, op + ctrl <= op_limit);
-#endif
- COPY_COMP_PIXEL(encoder, op);
-
- ASSERT(encoder->usr, op <= op_limit);
-
- for (--ctrl; ctrl; ctrl--) {
- COPY_COMP_PIXEL(encoder, op);
- ASSERT(encoder->usr, op <= op_limit);
- }
- }
-
- if (LZ_EXPECT_CONDITIONAL(op < op_limit)) {
- ctrl = decode(encoder);
- } else {
- loop = FALSE;
- }
- } while (LZ_EXPECT_CONDITIONAL(loop));
-
- return (op - out_buf);
-}
-
-#undef LZ_PLT
-#undef PLT8
-#undef PLT4_BE
-#undef PLT4_LE
-#undef PLT1_BE
-#undef PLT1_LE
-#undef LZ_RGB16
-#undef LZ_RGB24
-#undef LZ_RGB32
-#undef LZ_RGB_ALPHA
-#undef TO_RGB32
-#undef OUT_PIXEL
-#undef FNAME
-#undef COPY_PIXEL
-#undef COPY_REF_PIXEL
-#undef COPY_COMP_PIXEL
-#undef COPY_PLT_ENTRY
-#undef CAST_PLT_DISTANCE
diff --git a/common/marshaller.c b/common/marshaller.c
deleted file mode 100644
index 9023d08..0000000
--- a/common/marshaller.c
+++ /dev/null
@@ -1,615 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "marshaller.h"
-#include "mem.h"
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#ifdef WORDS_BIGENDIAN
-#define write_int8(ptr,v) (*((int8_t *)(ptr)) = v)
-#define write_uint8(ptr,v) (*((uint8_t *)(ptr)) = v)
-#define write_int16(ptr,v) (*((int16_t *)(ptr)) = SPICE_BYTESWAP16((uint16_t)(v)))
-#define write_uint16(ptr,v) (*((uint16_t *)(ptr)) = SPICE_BYTESWAP16((uint16_t)(v)))
-#define write_int32(ptr,v) (*((int32_t *)(ptr)) = SPICE_BYTESWAP32((uint32_t)(v)))
-#define write_uint32(ptr,v) (*((uint32_t *)(ptr)) = SPICE_BYTESWAP32((uint32_t)(v)))
-#define write_int64(ptr,v) (*((int64_t *)(ptr)) = SPICE_BYTESWAP64((uint64_t)(v)))
-#define write_uint64(ptr,v) (*((uint64_t *)(ptr)) = SPICE_BYTESWAP64((uint64_t)(v)))
-#else
-#define write_int8(ptr,v) (*((int8_t *)(ptr)) = v)
-#define write_uint8(ptr,v) (*((uint8_t *)(ptr)) = v)
-#define write_int16(ptr,v) (*((int16_t *)(ptr)) = v)
-#define write_uint16(ptr,v) (*((uint16_t *)(ptr)) = v)
-#define write_int32(ptr,v) (*((int32_t *)(ptr)) = v)
-#define write_uint32(ptr,v) (*((uint32_t *)(ptr)) = v)
-#define write_int64(ptr,v) (*((int64_t *)(ptr)) = v)
-#define write_uint64(ptr,v) (*((uint64_t *)(ptr)) = v)
-#endif
-
-typedef struct {
- uint8_t *data;
- size_t len;
- spice_marshaller_item_free_func free_data;
- void *opaque;
-} MarshallerItem;
-
-/* Try to fit in 4k page with 2*pointer-size overhead (next ptr and malloc size) */
-#define MARSHALLER_BUFFER_SIZE (4096 - sizeof(void *) * 2)
-
-typedef struct MarshallerBuffer MarshallerBuffer;
-struct MarshallerBuffer {
- MarshallerBuffer *next;
- uint8_t data[MARSHALLER_BUFFER_SIZE];
-};
-
-#define N_STATIC_ITEMS 4
-
-typedef struct SpiceMarshallerData SpiceMarshallerData;
-
-typedef struct {
- SpiceMarshaller *marshaller;
- int item_nr;
- int is_64bit;
- size_t offset;
-} MarshallerRef;
-
-struct SpiceMarshaller {
- size_t total_size;
- SpiceMarshallerData *data;
- SpiceMarshaller *next;
-
- MarshallerRef pointer_ref;
-
- int n_items;
- int items_size; /* number of items availible in items */
- MarshallerItem *items;
-
- MarshallerItem static_items[N_STATIC_ITEMS];
-};
-
-struct SpiceMarshallerData {
- size_t total_size;
- size_t base;
- SpiceMarshaller *marshallers;
- SpiceMarshaller *last_marshaller;
-
- size_t current_buffer_position;
- MarshallerBuffer *current_buffer;
- MarshallerItem *current_buffer_item;
- MarshallerBuffer *buffers;
-
- SpiceMarshaller static_marshaller;
- MarshallerBuffer static_buffer;
-};
-
-static void spice_marshaller_init(SpiceMarshaller *m,
- SpiceMarshallerData *data)
-{
- m->data = data;
- m->next = NULL;
- m->total_size = 0;
- m->pointer_ref.marshaller = NULL;
- m->n_items = 0;
- m->items_size = N_STATIC_ITEMS;
- m->items = m->static_items;
-}
-
-SpiceMarshaller *spice_marshaller_new(void)
-{
- SpiceMarshallerData *d;
- SpiceMarshaller *m;
-
- d = spice_new(SpiceMarshallerData, 1);
-
- d->last_marshaller = d->marshallers = &d->static_marshaller;
- d->total_size = 0;
- d->base = 0;
- d->buffers = &d->static_buffer;
- d->buffers->next = NULL;
- d->current_buffer = d->buffers;
- d->current_buffer_position = 0;
- d->current_buffer_item = NULL;
-
- m = &d->static_marshaller;
- spice_marshaller_init(m, d);
-
- return m;
-}
-
-static void free_item_data(SpiceMarshaller *m)
-{
- MarshallerItem *item;
- int i;
-
- /* Free all user data */
- for (i = 0; i < m->n_items; i++) {
- item = &m->items[i];
- if (item->free_data != NULL) {
- item->free_data(item->data, item->opaque);
- }
- }
-}
-
-static void free_items(SpiceMarshaller *m)
-{
- if (m->items != m->static_items) {
- free(m->items);
- }
-}
-
-void spice_marshaller_reset(SpiceMarshaller *m)
-{
- SpiceMarshaller *m2, *next;
- SpiceMarshallerData *d;
-
- /* Only supported for root marshaller */
- assert(m->data->marshallers == m);
-
- for (m2 = m; m2 != NULL; m2 = next) {
- next = m2->next;
- free_item_data(m2);
-
- /* Free non-root marshallers */
- if (m2 != m) {
- free_items(m2);
- free(m2);
- }
- }
-
- m->next = NULL;
- m->n_items = 0;
- m->total_size = 0;
-
- d = m->data;
- d->last_marshaller = d->marshallers;
- d->total_size = 0;
- d->base = 0;
- d->current_buffer_item = NULL;
- d->current_buffer = d->buffers;
- d->current_buffer_position = 0;
-}
-
-void spice_marshaller_destroy(SpiceMarshaller *m)
-{
- MarshallerBuffer *buf, *next;
- SpiceMarshallerData *d;
-
- /* Only supported for root marshaller */
- assert(m->data->marshallers == m);
-
- spice_marshaller_reset(m);
-
- free_items(m);
-
- d = m->data;
-
- buf = d->buffers->next;
- while (buf != NULL) {
- next = buf->next;
- free(buf);
- buf = next;
- }
-
- free(d);
-}
-
-static MarshallerItem *spice_marshaller_add_item(SpiceMarshaller *m)
-{
- MarshallerItem *item;
-
- if (m->n_items == m->items_size) {
- int items_size = m->items_size * 2;
-
- if (m->items == m->static_items) {
- m->items = spice_new(MarshallerItem, items_size);
- memcpy(m->items, m->static_items, sizeof(MarshallerItem) * m->n_items);
- } else {
- m->items = spice_renew(MarshallerItem, m->items, items_size);
- }
- m->items_size = items_size;
- }
- item = &m->items[m->n_items++];
- item->free_data = NULL;
-
- return item;
-}
-
-static size_t remaining_buffer_size(SpiceMarshallerData *d)
-{
- return MARSHALLER_BUFFER_SIZE - d->current_buffer_position;
-}
-
-uint8_t *spice_marshaller_reserve_space(SpiceMarshaller *m, size_t size)
-{
- MarshallerItem *item;
- SpiceMarshallerData *d;
- uint8_t *res;
-
- if (size == 0) {
- return NULL;
- }
-
- d = m->data;
-
- /* Check current item */
- item = &m->items[m->n_items - 1];
- if (item == d->current_buffer_item &&
- remaining_buffer_size(d) >= size) {
- assert(m->n_items >= 1);
- /* We can piggy back on existing item+buffer */
- res = item->data + item->len;
- item->len += size;
- d->current_buffer_position += size;
- d->total_size += size;
- m->total_size += size;
- return res;
- }
-
- item = spice_marshaller_add_item(m);
-
- if (remaining_buffer_size(d) >= size) {
- /* Fits in current buffer */
- item->data = d->current_buffer->data + d->current_buffer_position;
- item->len = size;
- d->current_buffer_position += size;
- d->current_buffer_item = item;
- } else if (size > MARSHALLER_BUFFER_SIZE / 2) {
- /* Large item, allocate by itself */
- item->data = (uint8_t *)spice_malloc(size);
- item->len = size;
- item->free_data = (spice_marshaller_item_free_func)free;
- item->opaque = NULL;
- } else {
- /* Use next buffer */
- if (d->current_buffer->next == NULL) {
- d->current_buffer->next = spice_new(MarshallerBuffer, 1);
- d->current_buffer->next->next = NULL;
- }
- d->current_buffer = d->current_buffer->next;
- d->current_buffer_position = size;
- d->current_buffer_item = item;
- item->data = d->current_buffer->data;
- item->len = size;
- }
-
- d->total_size += size;
- m->total_size += size;
- return item->data;
-}
-
-void spice_marshaller_unreserve_space(SpiceMarshaller *m, size_t size)
-{
- MarshallerItem *item;
-
- if (size == 0) {
- return;
- }
-
- item = &m->items[m->n_items - 1];
-
- assert(item->len >= size);
- item->len -= size;
-}
-
-uint8_t *spice_marshaller_add_ref_full(SpiceMarshaller *m, uint8_t *data, size_t size,
- spice_marshaller_item_free_func free_data, void *opaque)
-{
- MarshallerItem *item;
- SpiceMarshallerData *d;
-
- if (data == NULL || size == 0) {
- return NULL;
- }
-
- item = spice_marshaller_add_item(m);
- item->data = data;
- item->len = size;
- item->free_data = free_data;
- item->opaque = opaque;
-
- d = m->data;
- m->total_size += size;
- d->total_size += size;
-
- return data;
-}
-
-uint8_t *spice_marshaller_add(SpiceMarshaller *m, uint8_t *data, size_t size)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, size);
- memcpy(ptr, data, size);
- return ptr;
-}
-
-uint8_t *spice_marshaller_add_ref(SpiceMarshaller *m, uint8_t *data, size_t size)
-{
- return spice_marshaller_add_ref_full(m, data, size, NULL, NULL);
-}
-
-void spice_marshaller_add_ref_chunks(SpiceMarshaller *m, SpiceChunks *chunks)
-{
- unsigned int i;
-
- for (i = 0; i < chunks->num_chunks; i++) {
- spice_marshaller_add_ref(m, chunks->chunk[i].data,
- chunks->chunk[i].len);
- }
-}
-
-SpiceMarshaller *spice_marshaller_get_submarshaller(SpiceMarshaller *m)
-{
- SpiceMarshallerData *d;
- SpiceMarshaller *m2;
-
- d = m->data;
-
- m2 = spice_new(SpiceMarshaller, 1);
- spice_marshaller_init(m2, d);
-
- d->last_marshaller->next = m2;
- d->last_marshaller = m2;
-
- return m2;
-}
-
-SpiceMarshaller *spice_marshaller_get_ptr_submarshaller(SpiceMarshaller *m, int is_64bit)
-{
- SpiceMarshaller *m2;
- uint8_t *p;
- int size;
-
- size = is_64bit ? 8 : 4;
-
- p = spice_marshaller_reserve_space(m, size);
- memset(p, 0, size);
- m2 = spice_marshaller_get_submarshaller(m);
- m2->pointer_ref.marshaller = m;
- m2->pointer_ref.item_nr = m->n_items - 1;
- m2->pointer_ref.offset = m->items[m->n_items - 1].len - size;
- m2->pointer_ref.is_64bit = is_64bit;
-
- return m2;
-}
-
-uint8_t *lookup_ref(MarshallerRef *ref)
-{
- MarshallerItem *item;
-
- item = &ref->marshaller->items[ref->item_nr];
- return item->data + ref->offset;
-}
-
-
-void spice_marshaller_set_base(SpiceMarshaller *m, size_t base)
-{
- /* Only supported for root marshaller */
- assert(m->data->marshallers == m);
-
- m->data->base = base;
-}
-
-uint8_t *spice_marshaller_linearize(SpiceMarshaller *m, size_t skip_bytes,
- size_t *len, int *free_res)
-{
- MarshallerItem *item;
- uint8_t *res, *p;
- int i;
-
- /* Only supported for root marshaller */
- assert(m->data->marshallers == m);
-
- if (m->n_items == 1) {
- *free_res = FALSE;
- if (m->items[0].len <= skip_bytes) {
- *len = 0;
- return NULL;
- }
- *len = m->items[0].len - skip_bytes;
- return m->items[0].data + skip_bytes;
- }
-
- *free_res = TRUE;
- res = (uint8_t *)spice_malloc(m->data->total_size - skip_bytes);
- *len = m->data->total_size - skip_bytes;
- p = res;
-
- do {
- for (i = 0; i < m->n_items; i++) {
- item = &m->items[i];
-
- if (item->len <= skip_bytes) {
- skip_bytes -= item->len;
- continue;
- }
- memcpy(p, item->data + skip_bytes, item->len - skip_bytes);
- p += item->len - skip_bytes;
- skip_bytes = 0;
- }
- m = m->next;
- } while (m != NULL);
-
- return res;
-}
-
-uint8_t *spice_marshaller_get_ptr(SpiceMarshaller *m)
-{
- return m->items[0].data;
-}
-
-size_t spice_marshaller_get_offset(SpiceMarshaller *m)
-{
- SpiceMarshaller *m2;
- size_t offset;
-
- offset = 0;
- m2 = m->data->marshallers;
- while (m2 != m) {
- offset += m2->total_size;
- m2 = m2->next;
- }
- return offset - m->data->base;
-}
-
-size_t spice_marshaller_get_size(SpiceMarshaller *m)
-{
- return m->total_size;
-}
-
-size_t spice_marshaller_get_total_size(SpiceMarshaller *m)
-{
- return m->data->total_size;
-}
-
-void spice_marshaller_flush(SpiceMarshaller *m)
-{
- SpiceMarshaller *m2;
- uint8_t *ptr_pos;
-
- /* Only supported for root marshaller */
- assert(m->data->marshallers == m);
-
- for (m2 = m; m2 != NULL; m2 = m2->next) {
- if (m2->pointer_ref.marshaller != NULL && m2->total_size > 0) {
- ptr_pos = lookup_ref(&m2->pointer_ref);
- if (m2->pointer_ref.is_64bit) {
- write_uint64(ptr_pos,
- spice_marshaller_get_offset(m2));
- } else {
- write_uint32(ptr_pos,
- spice_marshaller_get_offset(m2));
- }
- }
- }
-}
-
-#ifndef WIN32
-int spice_marshaller_fill_iovec(SpiceMarshaller *m, struct iovec *vec,
- int n_vec, size_t skip_bytes)
-{
- MarshallerItem *item;
- int v, i;
-
- /* Only supported for root marshaller */
- assert(m->data->marshallers == m);
-
- v = 0;
- do {
- for (i = 0; i < m->n_items; i++) {
- item = &m->items[i];
-
- if (item->len <= skip_bytes) {
- skip_bytes -= item->len;
- continue;
- }
- if (v == n_vec) {
- return v; /* Not enough space in vec */
- }
- vec[v].iov_base = (void *)item->data + skip_bytes;
- vec[v].iov_len = item->len - skip_bytes;
- skip_bytes = 0;
- v++;
- }
- m = m->next;
- } while (m != NULL);
-
- return v;
-}
-#endif
-
-void *spice_marshaller_add_uint64(SpiceMarshaller *m, uint64_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(uint64_t));
- write_uint64(ptr, v);
- return (void *)ptr;
-}
-
-void *spice_marshaller_add_int64(SpiceMarshaller *m, int64_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(int64_t));
- write_int64(ptr, v);
- return (void *)ptr;
-}
-
-void *spice_marshaller_add_uint32(SpiceMarshaller *m, uint32_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(uint32_t));
- write_uint32(ptr, v);
- return (void *)ptr;
-}
-
-void spice_marshaller_set_uint32(SpiceMarshaller *m, void *ref, uint32_t v)
-{
- write_uint32((uint8_t *)ref, v);
-}
-
-void *spice_marshaller_add_int32(SpiceMarshaller *m, int32_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(int32_t));
- write_int32(ptr, v);
- return (void *)ptr;
-}
-
-void *spice_marshaller_add_uint16(SpiceMarshaller *m, uint16_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(uint16_t));
- write_uint16(ptr, v);
- return (void *)ptr;
-}
-
-void *spice_marshaller_add_int16(SpiceMarshaller *m, int16_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(int16_t));
- write_int16(ptr, v);
- return (void *)ptr;
-}
-
-void *spice_marshaller_add_uint8(SpiceMarshaller *m, uint8_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(uint8_t));
- write_uint8(ptr, v);
- return (void *)ptr;
-}
-
-void *spice_marshaller_add_int8(SpiceMarshaller *m, int8_t v)
-{
- uint8_t *ptr;
-
- ptr = spice_marshaller_reserve_space(m, sizeof(int8_t));
- write_int8(ptr, v);
- return (void *)ptr;
-}
diff --git a/common/marshaller.h b/common/marshaller.h
deleted file mode 100644
index 0a61fef..0000000
--- a/common/marshaller.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_MARSHALLER
-#define _H_MARSHALLER
-
-#include <spice/types.h>
-#include "mem.h"
-#ifndef WIN32
-#include <sys/uio.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SpiceMarshaller SpiceMarshaller;
-typedef void (*spice_marshaller_item_free_func)(uint8_t *data, void *opaque);
-
-SpiceMarshaller *spice_marshaller_new(void);
-void spice_marshaller_reset(SpiceMarshaller *m);
-void spice_marshaller_destroy(SpiceMarshaller *m);
-uint8_t *spice_marshaller_reserve_space(SpiceMarshaller *m, size_t size);
-void spice_marshaller_unreserve_space(SpiceMarshaller *m, size_t size);
-uint8_t *spice_marshaller_add(SpiceMarshaller *m, uint8_t *data, size_t size);
-uint8_t *spice_marshaller_add_ref(SpiceMarshaller *m, uint8_t *data, size_t size);
-uint8_t *spice_marshaller_add_ref_full(SpiceMarshaller *m, uint8_t *data, size_t size,
- spice_marshaller_item_free_func free_data, void *opaque);
-void spice_marshaller_add_ref_chunks(SpiceMarshaller *m, SpiceChunks *chunks);
-void spice_marshaller_flush(SpiceMarshaller *m);
-void spice_marshaller_set_base(SpiceMarshaller *m, size_t base);
-uint8_t *spice_marshaller_linearize(SpiceMarshaller *m, size_t skip,
- size_t *len, int *free_res);
-uint8_t *spice_marshaller_get_ptr(SpiceMarshaller *m);
-size_t spice_marshaller_get_offset(SpiceMarshaller *m);
-size_t spice_marshaller_get_size(SpiceMarshaller *m);
-size_t spice_marshaller_get_total_size(SpiceMarshaller *m);
-SpiceMarshaller *spice_marshaller_get_submarshaller(SpiceMarshaller *m);
-SpiceMarshaller *spice_marshaller_get_ptr_submarshaller(SpiceMarshaller *m, int is_64bit);
-#ifndef WIN32
-int spice_marshaller_fill_iovec(SpiceMarshaller *m, struct iovec *vec,
- int n_vec, size_t skip_bytes);
-#endif
-void *spice_marshaller_add_uint64(SpiceMarshaller *m, uint64_t v);
-void *spice_marshaller_add_int64(SpiceMarshaller *m, int64_t v);
-void *spice_marshaller_add_uint32(SpiceMarshaller *m, uint32_t v);
-void *spice_marshaller_add_int32(SpiceMarshaller *m, int32_t v);
-void *spice_marshaller_add_uint16(SpiceMarshaller *m, uint16_t v);
-void *spice_marshaller_add_int16(SpiceMarshaller *m, int16_t v);
-void *spice_marshaller_add_uint8(SpiceMarshaller *m, uint8_t v);
-void *spice_marshaller_add_int8(SpiceMarshaller *m, int8_t v);
-
-void spice_marshaller_set_uint32(SpiceMarshaller *m, void *ref, uint32_t v);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/mem.c b/common/mem.c
deleted file mode 100644
index 5298e37..0000000
--- a/common/mem.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "mem.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#ifndef MALLOC_ERROR
-#define MALLOC_ERROR(format, ...) { \
- printf(format "\n", ## __VA_ARGS__); \
- abort(); \
-}
-#endif
-
-size_t spice_strnlen(const char *str, size_t max_len)
-{
- size_t len = 0;
-
- while (len < max_len && *str != 0) {
- len++;
- str++;
- }
-
- return len;
-}
-
-char *spice_strdup(const char *str)
-{
- char *copy;
-
- if (str == NULL) {
- return NULL;
- }
-
- copy = (char *)spice_malloc(strlen(str) + 1);
- strcpy(copy, str);
- return copy;
-}
-
-char *spice_strndup(const char *str, size_t n_bytes)
-{
- char *copy;
-
- if (str == NULL) {
- return NULL;
- }
-
- copy = (char *)spice_malloc(n_bytes + 1);
- strncpy(copy, str, n_bytes);
- copy[n_bytes] = 0;
- return copy;
-}
-
-void *spice_memdup(const void *mem, size_t n_bytes)
-{
- void *copy;
-
- if (mem == NULL) {
- return NULL;
- }
-
- copy = spice_malloc(n_bytes);
- memcpy(copy, mem, n_bytes);
- return copy;
-}
-
-void *spice_malloc(size_t n_bytes)
-{
- void *mem;
-
- if (SPICE_LIKELY(n_bytes)) {
- mem = malloc(n_bytes);
-
- if (SPICE_LIKELY(mem != NULL)) {
- return mem;
- }
-
- MALLOC_ERROR("spice_malloc: panic: unable to allocate %lu bytes\n",
- (unsigned long)n_bytes);
- }
- return NULL;
-}
-
-void *spice_malloc0(size_t n_bytes)
-{
- void *mem;
-
- if (SPICE_LIKELY(n_bytes)) {
- mem = calloc(1, n_bytes);
-
- if (SPICE_LIKELY(mem != NULL)) {
- return mem;
- }
-
- MALLOC_ERROR("spice_malloc0: panic: unable to allocate %lu bytes\n",
- (unsigned long)n_bytes);
- }
- return NULL;
-}
-
-void *spice_realloc(void *mem, size_t n_bytes)
-{
- if (SPICE_LIKELY(n_bytes)) {
- mem = realloc(mem, n_bytes);
-
- if (SPICE_LIKELY(mem != NULL)) {
- return mem;
- }
-
- MALLOC_ERROR("spice_realloc: panic: unable to allocate %lu bytes\n",
- (unsigned long)n_bytes);
- }
-
- free(mem);
-
- return NULL;
-}
-
-#define SIZE_OVERFLOWS(a,b) (SPICE_UNLIKELY ((a) > SIZE_MAX / (b)))
-
-void *spice_malloc_n(size_t n_blocks, size_t n_block_bytes)
-{
- if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) {
- MALLOC_ERROR("spice_malloc_n: overflow allocating %lu*%lu bytes",
- (unsigned long)n_blocks, (unsigned long)n_block_bytes);
- }
-
- return spice_malloc(n_blocks * n_block_bytes);
-}
-
-void *spice_malloc_n_m(size_t n_blocks, size_t n_block_bytes, size_t extra_size)
-{
- size_t size1, size2;
- if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) {
- MALLOC_ERROR("spice_malloc_n: overflow allocating %lu*%lu + %lubytes",
- (unsigned long)n_blocks, (unsigned long)n_block_bytes, (unsigned long)extra_size);
- }
- size1 = n_blocks * n_block_bytes;
- size2 = size1 + extra_size;
- if (size2 < size1) {
- MALLOC_ERROR("spice_malloc_n: overflow allocating %lu*%lu + %lubytes",
- (unsigned long)n_blocks, (unsigned long)n_block_bytes, (unsigned long)extra_size);
- }
- return spice_malloc(size2);
-}
-
-
-void *spice_malloc0_n(size_t n_blocks, size_t n_block_bytes)
-{
- if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) {
- MALLOC_ERROR("spice_malloc0_n: overflow allocating %lu*%lu bytes",
- (unsigned long)n_blocks, (unsigned long)n_block_bytes);
- }
-
- return spice_malloc0 (n_blocks * n_block_bytes);
-}
-
-void *spice_realloc_n(void *mem, size_t n_blocks, size_t n_block_bytes)
-{
- if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) {
- MALLOC_ERROR("spice_realloc_n: overflow allocating %lu*%lu bytes",
- (unsigned long)n_blocks, (unsigned long)n_block_bytes);
- }
-
- return spice_realloc(mem, n_blocks * n_block_bytes);
-}
-
-SpiceChunks *spice_chunks_new(uint32_t count)
-{
- SpiceChunks *chunks;
-
- chunks = (SpiceChunks *)spice_malloc_n_m(count, sizeof(SpiceChunk), sizeof(SpiceChunks));
- chunks->flags = 0;
- chunks->num_chunks = count;
-
- return chunks;
-}
-
-SpiceChunks *spice_chunks_new_linear(uint8_t *data, uint32_t len)
-{
- SpiceChunks *chunks;
-
- chunks = spice_chunks_new(1);
- chunks->data_size = chunks->chunk[0].len = len;
- chunks->chunk[0].data = data;
- return chunks;
-}
-
-void spice_chunks_destroy(SpiceChunks *chunks)
-{
- unsigned int i;
-
- if (chunks->flags & SPICE_CHUNKS_FLAGS_FREE) {
- for (i = 0; i < chunks->num_chunks; i++) {
- free(chunks->chunk[i].data);
- }
- }
-
- free(chunks);
-}
-
-void spice_chunks_linearize(SpiceChunks *chunks)
-{
- uint8_t *data, *p;
- unsigned int i;
-
- if (chunks->num_chunks > 1) {
- data = (uint8_t*)spice_malloc(chunks->data_size);
- for (p = data, i = 0; i < chunks->num_chunks; i++) {
- memcpy(p, chunks->chunk[i].data,
- chunks->chunk[i].len);
- p += chunks->chunk[i].len;
- }
- if (chunks->flags & SPICE_CHUNKS_FLAGS_FREE) {
- for (i = 0; i < chunks->num_chunks; i++) {
- free(chunks->chunk[i].data);
- }
- }
- chunks->num_chunks = 1;
- chunks->flags |= SPICE_CHUNKS_FLAGS_FREE;
- chunks->flags &= ~SPICE_CHUNKS_FLAGS_UNSTABLE;
- chunks->chunk[0].data = data;
- chunks->chunk[0].len = chunks->data_size;
- }
-}
-
-void spice_buffer_reserve(SpiceBuffer *buffer, size_t len)
-{
- if ((buffer->capacity - buffer->offset) < len) {
- buffer->capacity += (len + 1024);
- buffer->buffer = (uint8_t*)spice_realloc(buffer->buffer, buffer->capacity);
- }
-}
-
-int spice_buffer_empty(SpiceBuffer *buffer)
-{
- return buffer->offset == 0;
-}
-
-uint8_t *spice_buffer_end(SpiceBuffer *buffer)
-{
- return buffer->buffer + buffer->offset;
-}
-
-void spice_buffer_reset(SpiceBuffer *buffer)
-{
- buffer->offset = 0;
-}
-
-void spice_buffer_free(SpiceBuffer *buffer)
-{
- free(buffer->buffer);
- buffer->offset = 0;
- buffer->capacity = 0;
- buffer->buffer = NULL;
-}
-
-void spice_buffer_append(SpiceBuffer *buffer, const void *data, size_t len)
-{
- spice_buffer_reserve(buffer, len);
- memcpy(buffer->buffer + buffer->offset, data, len);
- buffer->offset += len;
-}
-
-size_t spice_buffer_copy(SpiceBuffer *buffer, void *dest, size_t len)
-{
- len = MIN(buffer->offset, len);
- memcpy(dest, buffer->buffer, len);
- return len;
-}
-
-size_t spice_buffer_remove(SpiceBuffer *buffer, size_t len)
-{
- len = MIN(buffer->offset, len);
- memmove(buffer->buffer, buffer->buffer + len, buffer->offset - len);
- buffer->offset -= len;
- return len;
-}
diff --git a/common/mem.h b/common/mem.h
deleted file mode 100644
index af89ba6..0000000
--- a/common/mem.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2010 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_MEM
-#define _H_MEM
-
-#include <stdlib.h>
-#include <spice/macros.h>
-
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef STDC_HEADERS
-# include <stdlib.h>
-# include <stddef.h>
-#else
-# ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-# endif
-#endif
-#ifdef HAVE_ALLOCA_H
-# include <alloca.h>
-#elif defined __GNUC__
-#if !defined alloca
-# define alloca __builtin_alloca
-#endif
-#elif defined _AIX
-# define alloca __alloca
-#elif defined _MSC_VER
-# include <malloc.h>
-# define alloca _alloca
-#else
-# ifndef HAVE_ALLOCA
-# ifdef __cplusplus
-extern "C"
-# endif
-void *alloca (size_t);
-# endif
-#endif
-
-typedef struct SpiceChunk {
- uint8_t *data;
- uint32_t len;
-} SpiceChunk;
-
-enum {
- SPICE_CHUNKS_FLAGS_UNSTABLE = (1<<0),
- SPICE_CHUNKS_FLAGS_FREE = (1<<1)
-};
-
-typedef struct SpiceChunks {
- uint32_t data_size;
- uint32_t num_chunks;
- uint32_t flags;
- SpiceChunk chunk[0];
-} SpiceChunks;
-
-typedef struct SpiceBuffer
-{
- size_t capacity;
- size_t offset;
- uint8_t *buffer;
-} SpiceBuffer;
-
-char *spice_strdup(const char *str) SPICE_GNUC_MALLOC;
-char *spice_strndup(const char *str, size_t n_bytes) SPICE_GNUC_MALLOC;
-void *spice_memdup(const void *mem, size_t n_bytes) SPICE_GNUC_MALLOC;
-void *spice_malloc(size_t n_bytes) SPICE_GNUC_MALLOC SPICE_GNUC_ALLOC_SIZE(1);
-void *spice_malloc0(size_t n_bytes) SPICE_GNUC_MALLOC SPICE_GNUC_ALLOC_SIZE(1);
-void *spice_realloc(void *mem, size_t n_bytes) SPICE_GNUC_WARN_UNUSED_RESULT;
-void *spice_malloc_n(size_t n_blocks, size_t n_block_bytes) SPICE_GNUC_MALLOC SPICE_GNUC_ALLOC_SIZE2(1,2);
-void *spice_malloc_n_m(size_t n_blocks, size_t n_block_bytes, size_t extra_size) SPICE_GNUC_MALLOC;
-void *spice_malloc0_n(size_t n_blocks, size_t n_block_bytes) SPICE_GNUC_MALLOC SPICE_GNUC_ALLOC_SIZE2(1,2);
-void *spice_realloc_n(void *mem, size_t n_blocks, size_t n_block_bytes) SPICE_GNUC_WARN_UNUSED_RESULT;
-SpiceChunks *spice_chunks_new(uint32_t count) SPICE_GNUC_MALLOC;
-SpiceChunks *spice_chunks_new_linear(uint8_t *data, uint32_t len) SPICE_GNUC_MALLOC;
-void spice_chunks_destroy(SpiceChunks *chunks);
-void spice_chunks_linearize(SpiceChunks *chunks);
-
-size_t spice_strnlen(const char *str, size_t max_len);
-
-/* Optimize: avoid the call to the (slower) _n function if we can
- * determine at compile-time that no overflow happens.
- */
-#if defined (__GNUC__) && (__GNUC__ >= 2) && defined (__OPTIMIZE__)
-# define _SPICE_NEW(struct_type, n_structs, func) \
- (struct_type *) (__extension__ ({ \
- size_t __n = (size_t) (n_structs); \
- size_t __s = sizeof (struct_type); \
- void *__p; \
- if (__s == 1) \
- __p = spice_##func (__n); \
- else if (__builtin_constant_p (__n) && \
- __n <= SIZE_MAX / __s) \
- __p = spice_##func (__n * __s); \
- else \
- __p = spice_##func##_n (__n, __s); \
- __p; \
- }))
-# define _SPICE_RENEW(struct_type, mem, n_structs, func) \
- (struct_type *) (__extension__ ({ \
- size_t __n = (size_t) (n_structs); \
- size_t __s = sizeof (struct_type); \
- void *__p = (void *) (mem); \
- if (__s == 1) \
- __p = spice_##func (__p, __n); \
- else if (__builtin_constant_p (__n) && \
- __n <= SIZE_MAX / __s) \
- __p = spice_##func (__p, __n * __s); \
- else \
- __p = spice_##func##_n (__p, __n, __s); \
- __p; \
- }))
-#else
-
-/* Unoptimized version: always call the _n() function. */
-
-#define _SPICE_NEW(struct_type, n_structs, func) \
- ((struct_type *) spice_##func##_n ((n_structs), sizeof (struct_type)))
-#define _SPICE_RENEW(struct_type, mem, n_structs, func) \
- ((struct_type *) spice_##func##_n (mem, (n_structs), sizeof (struct_type)))
-
-#endif
-
-#define spice_new(struct_type, n_structs) _SPICE_NEW(struct_type, n_structs, malloc)
-#define spice_new0(struct_type, n_structs) _SPICE_NEW(struct_type, n_structs, malloc0)
-#define spice_renew(struct_type, mem, n_structs) _SPICE_RENEW(struct_type, mem, n_structs, realloc)
-
-/* Buffer management */
-void spice_buffer_reserve(SpiceBuffer *buffer, size_t len);
-int spice_buffer_empty(SpiceBuffer *buffer);
-uint8_t *spice_buffer_end(SpiceBuffer *buffer);
-void spice_buffer_reset(SpiceBuffer *buffer);
-void spice_buffer_free(SpiceBuffer *buffer);
-void spice_buffer_append(SpiceBuffer *buffer, const void *data, size_t len);
-size_t spice_buffer_copy(SpiceBuffer *buffer, void *dest, size_t len);
-size_t spice_buffer_remove(SpiceBuffer *buffer, size_t len);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/common/messages.h b/common/messages.h
deleted file mode 100644
index ec58da5..0000000
--- a/common/messages.h
+++ /dev/null
@@ -1,525 +0,0 @@
-/*
- Copyright (C) 2009-2010 Red Hat, Inc.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
-
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in
- the documentation and/or other materials provided with the
- distribution.
- * Neither the name of the copyright holder nor the names of its
- contributors may be used to endorse or promote products derived
- from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
- IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef _H_MESSAGES
-#define _H_MESSAGES
-
-#include <spice/protocol.h>
-#include "draw.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SpiceMsgData {
- uint32_t data_size;
- uint8_t data[0];
-} SpiceMsgData;
-
-typedef struct SpiceMsgEmpty {
-} SpiceMsgEmpty;
-
-typedef struct SpiceMsgInputsInit {
- uint32_t keyboard_modifiers;
-} SpiceMsgInputsInit;
-
-typedef struct SpiceMsgInputsKeyModifiers {
- uint32_t modifiers;
-} SpiceMsgInputsKeyModifiers;
-
-typedef struct SpiceMsgMainMultiMediaTime {
- uint32_t time;
-} SpiceMsgMainMultiMediaTime;
-
-typedef struct SpiceMsgMainMigrationBegin {
- uint16_t port;
- uint16_t sport;
- uint32_t host_size;
- uint8_t *host_data;
- uint16_t pub_key_type;
- uint32_t pub_key_size;
- uint8_t *pub_key_data;
- uint32_t cert_subject_size;
- uint8_t *cert_subject_data;
-} SpiceMsgMainMigrationBegin;
-
-typedef struct SpiceMsgMainMigrationSwitchHost {
- uint16_t port;
- uint16_t sport;
- uint32_t host_size;
- uint8_t *host_data;
- uint32_t cert_subject_size;
- uint8_t *cert_subject_data;
-} SpiceMsgMainMigrationSwitchHost;
-
-
-typedef struct SpiceMsgMigrate {
- uint32_t flags;
-} SpiceMsgMigrate;
-
-typedef struct SpiceResourceID {
- uint8_t type;
- uint64_t id;
-} SpiceResourceID;
-
-typedef struct SpiceResourceList {
- uint16_t count;
- SpiceResourceID resources[0];
-} SpiceResourceList;
-
-typedef struct SpiceMsgSetAck {
- uint32_t generation;
- uint32_t window;
-} SpiceMsgSetAck;
-
-typedef struct SpiceMsgcAckSync {
- uint32_t generation;
-} SpiceMsgcAckSync;
-
-typedef struct SpiceWaitForChannel {
- uint8_t channel_type;
- uint8_t channel_id;
- uint64_t message_serial;
-} SpiceWaitForChannel;
-
-typedef struct SpiceMsgWaitForChannels {
- uint8_t wait_count;
- SpiceWaitForChannel wait_list[0];
-} SpiceMsgWaitForChannels;
-
-typedef struct SpiceChannelId {
- uint8_t type;
- uint8_t id;
-} SpiceChannelId;
-
-typedef struct SpiceMsgMainInit {
- uint32_t session_id;
- uint32_t display_channels_hint;
- uint32_t supported_mouse_modes;
- uint32_t current_mouse_mode;
- uint32_t agent_connected;
- uint32_t agent_tokens;
- uint32_t multi_media_time;
- uint32_t ram_hint;
-} SpiceMsgMainInit;
-
-typedef struct SpiceMsgDisconnect {
- uint64_t time_stamp;
- uint32_t reason; // SPICE_ERR_?
-} SpiceMsgDisconnect;
-
-typedef struct SpiceMsgNotify {
- uint64_t time_stamp;
- uint32_t severity;
- uint32_t visibilty;
- uint32_t what;
- uint32_t message_len;
- uint8_t message[0];
-} SpiceMsgNotify;
-
-typedef struct SpiceMsgChannels {
- uint32_t num_of_channels;
- SpiceChannelId channels[0];
-} SpiceMsgChannels;
-
-typedef struct SpiceMsgMainName {
- uint32_t name_len;
- uint8_t name[0];
-} SpiceMsgMainName;
-
-typedef struct SpiceMsgMainUuid {
- uint8_t uuid[16];
-} SpiceMsgMainUuid;
-
-typedef struct SpiceMsgMainMouseMode {
- uint32_t supported_modes;
- uint32_t current_mode;
-} SpiceMsgMainMouseMode;
-
-typedef struct SpiceMsgPing {
- uint32_t id;
- uint64_t timestamp;
- void *data;
- uint32_t data_len;
-} SpiceMsgPing;
-
-typedef struct SpiceMsgMainAgentDisconnect {
- uint32_t error_code; // SPICE_ERR_?
-} SpiceMsgMainAgentDisconnect;
-
-#define SPICE_AGENT_MAX_DATA_SIZE 2048
-
-typedef struct SpiceMsgMainAgentTokens {
- uint32_t num_tokens;
-} SpiceMsgMainAgentTokens, SpiceMsgcMainAgentTokens, SpiceMsgcMainAgentStart;
-
-typedef struct SpiceMsgcClientInfo {
- uint64_t cache_size;
-} SpiceMsgcClientInfo;
-
-typedef struct SpiceMsgcMainMouseModeRequest {
- uint32_t mode;
-} SpiceMsgcMainMouseModeRequest;
-
-typedef struct SpiceCursor {
- uint32_t flags;
- SpiceCursorHeader header;
- uint32_t data_size;
- uint8_t *data;
-} SpiceCursor;
-
-typedef struct SpiceMsgDisplayMode {
- uint32_t x_res;
- uint32_t y_res;
- uint32_t bits;
-} SpiceMsgDisplayMode;
-
-typedef struct SpiceMsgSurfaceCreate {
- uint32_t surface_id;
- uint32_t width;
- uint32_t height;
- uint32_t format;
- uint32_t flags;
-} SpiceMsgSurfaceCreate;
-
-typedef struct SpiceMsgSurfaceDestroy {
- uint32_t surface_id;
-} SpiceMsgSurfaceDestroy;
-
-typedef struct SpiceMsgDisplayBase {
- uint32_t surface_id;
- SpiceRect box;
- SpiceClip clip;
-} SpiceMsgDisplayBase;
-
-typedef struct SpiceMsgDisplayDrawFill {
- SpiceMsgDisplayBase base;
- SpiceFill data;
-} SpiceMsgDisplayDrawFill;
-
-typedef struct SpiceMsgDisplayDrawOpaque {
- SpiceMsgDisplayBase base;
- SpiceOpaque data;
-} SpiceMsgDisplayDrawOpaque;
-
-typedef struct SpiceMsgDisplayDrawCopy {
- SpiceMsgDisplayBase base;
- SpiceCopy data;
-} SpiceMsgDisplayDrawCopy;
-
-typedef struct SpiceMsgDisplayDrawTransparent {
- SpiceMsgDisplayBase base;
- SpiceTransparent data;
-} SpiceMsgDisplayDrawTransparent;
-
-typedef struct SpiceMsgDisplayDrawAlphaBlend {
- SpiceMsgDisplayBase base;
- SpiceAlphaBlend data;
-} SpiceMsgDisplayDrawAlphaBlend;
-
-typedef struct SpiceMsgDisplayCopyBits {
- SpiceMsgDisplayBase base;
- SpicePoint src_pos;
-} SpiceMsgDisplayCopyBits;
-
-typedef SpiceMsgDisplayDrawCopy SpiceMsgDisplayDrawBlend;
-
-typedef struct SpiceMsgDisplayDrawRop3 {
- SpiceMsgDisplayBase base;
- SpiceRop3 data;
-} SpiceMsgDisplayDrawRop3;
-
-typedef struct SpiceMsgDisplayDrawBlackness {
- SpiceMsgDisplayBase base;
- SpiceBlackness data;
-} SpiceMsgDisplayDrawBlackness;
-
-typedef struct SpiceMsgDisplayDrawWhiteness {
- SpiceMsgDisplayBase base;
- SpiceWhiteness data;
-} SpiceMsgDisplayDrawWhiteness;
-
-typedef struct SpiceMsgDisplayDrawInvers {
- SpiceMsgDisplayBase base;
- SpiceInvers data;
-} SpiceMsgDisplayDrawInvers;
-
-typedef struct SpiceMsgDisplayDrawStroke {
- SpiceMsgDisplayBase base;
- SpiceStroke data;
-} SpiceMsgDisplayDrawStroke;
-
-typedef struct SpiceMsgDisplayDrawText {
- SpiceMsgDisplayBase base;
- SpiceText data;
-} SpiceMsgDisplayDrawText;
-
-typedef struct SpiceMsgDisplayInvalOne {
- uint64_t id;
-} SpiceMsgDisplayInvalOne;
-
-typedef struct SpiceMsgDisplayStreamCreate {
- uint32_t surface_id;
- uint32_t id;
- uint32_t flags;
- uint32_t codec_type;
- uint64_t stamp;
- uint32_t stream_width;
- uint32_t stream_height;
- uint32_t src_width;
- uint32_t src_height;
- SpiceRect dest;
- SpiceClip clip;
-} SpiceMsgDisplayStreamCreate;
-
-typedef struct SpiceMsgDisplayStreamData {
- uint32_t id;
- uint32_t multi_media_time;
- uint32_t data_size;
- uint8_t data[0];
-} SpiceMsgDisplayStreamData;
-
-typedef struct SpiceMsgDisplayStreamClip {
- uint32_t id;
- SpiceClip clip;
-} SpiceMsgDisplayStreamClip;
-
-typedef struct SpiceMsgDisplayStreamDestroy {
- uint32_t id;
-} SpiceMsgDisplayStreamDestroy;
-
-typedef struct SpiceMsgCursorInit {
- SpicePoint16 position;
- uint16_t trail_length;
- uint16_t trail_frequency;
- uint8_t visible;
- SpiceCursor cursor;
-} SpiceMsgCursorInit;
-
-typedef struct SpiceMsgCursorSet {
- SpicePoint16 position;
- uint8_t visible;
- SpiceCursor cursor;
-} SpiceMsgCursorSet;
-
-typedef struct SpiceMsgCursorMove {
- SpicePoint16 position;
-} SpiceMsgCursorMove;
-
-typedef struct SpiceMsgCursorTrail {
- uint16_t length;
- uint16_t frequency;
-} SpiceMsgCursorTrail;
-
-typedef struct SpiceMsgcDisplayInit {
- uint8_t pixmap_cache_id;
- int64_t pixmap_cache_size; //in pixels
- uint8_t glz_dictionary_id;
- int32_t glz_dictionary_window_size; // in pixels
-} SpiceMsgcDisplayInit;
-
-typedef struct SpiceMsgcKeyDown {
- uint32_t code;
-} SpiceMsgcKeyDown;
-
-typedef struct SpiceMsgcKeyUp {
- uint32_t code;
-} SpiceMsgcKeyUp;
-
-typedef struct SpiceMsgcKeyModifiers {
- uint32_t modifiers;
-} SpiceMsgcKeyModifiers;
-
-typedef struct SpiceMsgcMouseMotion {
- int32_t dx;
- int32_t dy;
- uint32_t buttons_state;
-} SpiceMsgcMouseMotion;
-
-typedef struct SpiceMsgcMousePosition {
- uint32_t x;
- uint32_t y;
- uint32_t buttons_state;
- uint8_t display_id;
-} SpiceMsgcMousePosition;
-
-typedef struct SpiceMsgcMousePress {
- int32_t button;
- int32_t buttons_state;
-} SpiceMsgcMousePress;
-
-typedef struct SpiceMsgcMouseRelease {
- int32_t button;
- int32_t buttons_state;
-} SpiceMsgcMouseRelease;
-
-typedef struct SpiceMsgAudioVolume {
- uint8_t nchannels;
- uint16_t volume[0];
-} SpiceMsgAudioVolume;
-
-typedef struct SpiceMsgAudioMute {
- uint8_t mute;
-} SpiceMsgAudioMute;
-
-typedef struct SpiceMsgPlaybackMode {
- uint32_t time;
- uint32_t mode; //SPICE_AUDIO_DATA_MODE_?
- uint8_t *data;
- uint32_t data_size;
-} SpiceMsgPlaybackMode, SpiceMsgcRecordMode;
-
-typedef struct SpiceMsgPlaybackStart {
- uint32_t channels;
- uint32_t format; //SPICE_AUDIO_FMT_?
- uint32_t frequency;
- uint32_t time;
-} SpiceMsgPlaybackStart;
-
-typedef struct SpiceMsgPlaybackPacket {
- uint32_t time;
- uint8_t *data;
- uint32_t data_size;
-} SpiceMsgPlaybackPacket, SpiceMsgcRecordPacket;
-
-typedef struct SpiceMsgRecordStart {
- uint32_t channels;
- uint32_t format; //SPICE_AUDIO_FMT_?
- uint32_t frequency;
-} SpiceMsgRecordStart;
-
-typedef struct SpiceMsgcRecordStartMark {
- uint32_t time;
-} SpiceMsgcRecordStartMark;
-
-typedef struct SpiceMsgTunnelInit {
- uint16_t max_num_of_sockets;
- uint32_t max_socket_data_size;
-} SpiceMsgTunnelInit;
-
-typedef uint8_t SpiceTunnelIPv4[4];
-
-typedef struct SpiceMsgTunnelIpInfo {
- uint16_t type;
- union {
- SpiceTunnelIPv4 ipv4;
- } u;
- uint8_t data[0];
-} SpiceMsgTunnelIpInfo;
-
-typedef struct SpiceMsgTunnelServiceIpMap {
- uint32_t service_id;
- SpiceMsgTunnelIpInfo virtual_ip;
-} SpiceMsgTunnelServiceIpMap;
-
-typedef struct SpiceMsgTunnelSocketOpen {
- uint16_t connection_id;
- uint32_t service_id;
- uint32_t tokens;
-} SpiceMsgTunnelSocketOpen;
-
-/* connection id must be the first field in msgs directed to a specific connection */
-
-typedef struct SpiceMsgTunnelSocketFin {
- uint16_t connection_id;
-} SpiceMsgTunnelSocketFin;
-
-typedef struct SpiceMsgTunnelSocketClose {
- uint16_t connection_id;
-} SpiceMsgTunnelSocketClose;
-
-typedef struct SpiceMsgTunnelSocketData {
- uint16_t connection_id;
- uint8_t data[0];
-} SpiceMsgTunnelSocketData;
-
-typedef struct SpiceMsgTunnelSocketTokens {
- uint16_t connection_id;
- uint32_t num_tokens;
-} SpiceMsgTunnelSocketTokens;
-
-typedef struct SpiceMsgTunnelSocketClosedAck {
- uint16_t connection_id;
-} SpiceMsgTunnelSocketClosedAck;
-
-typedef struct SpiceMsgcTunnelAddGenericService {
- uint32_t type;
- uint32_t id;
- uint32_t group;
- uint32_t port;
- uint64_t name;
- uint64_t description;
- union {
- SpiceMsgTunnelIpInfo ip;
- } u;
-} SpiceMsgcTunnelAddGenericService;
-
-typedef struct SpiceMsgcTunnelRemoveService {
- uint32_t id;
-} SpiceMsgcTunnelRemoveService;
-
-/* connection id must be the first field in msgs directed to a specific connection */
-
-typedef struct SpiceMsgcTunnelSocketOpenAck {
- uint16_t connection_id;
- uint32_t tokens;
-} SpiceMsgcTunnelSocketOpenAck;
-
-typedef struct SpiceMsgcTunnelSocketOpenNack {
- uint16_t connection_id;
-} SpiceMsgcTunnelSocketOpenNack;
-
-typedef struct SpiceMsgcTunnelSocketData {
- uint16_t connection_id;
- uint8_t data[0];
-} SpiceMsgcTunnelSocketData;
-
-typedef struct SpiceMsgcTunnelSocketFin {
- uint16_t connection_id;
-} SpiceMsgcTunnelSocketFin;
-
-typedef struct SpiceMsgcTunnelSocketClosed {
- uint16_t connection_id;
-} SpiceMsgcTunnelSocketClosed;
-
-typedef struct SpiceMsgcTunnelSocketClosedAck {
- uint16_t connection_id;
-} SpiceMsgcTunnelSocketClosedAck;
-
-typedef struct SpiceMsgcTunnelSocketTokens {
- uint16_t connection_id;
- uint32_t num_tokens;
-} SpiceMsgcTunnelSocketTokens;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _H_SPICE_PROTOCOL */
diff --git a/common/mutex.h b/common/mutex.h
deleted file mode 100644
index 6789b8f..0000000
--- a/common/mutex.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_MUTEX
-#define _H_MUTEX
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef _WIN32
-#include <windows.h>
-typedef CRITICAL_SECTION mutex_t;
-#define MUTEX_INIT(mutex) InitializeCriticalSection(&mutex)
-#define MUTEX_LOCK(mutex) EnterCriticalSection(&mutex)
-#define MUTEX_UNLOCK(mutex) LeaveCriticalSection(&mutex)
-#else
-#include <pthread.h>
-typedef pthread_mutex_t mutex_t;
-#define MUTEX_INIT(mutex) pthread_mutex_init(&mutex, NULL);
-#define MUTEX_LOCK(mutex) pthread_mutex_lock(&mutex)
-#define MUTEX_UNLOCK(mutex) pthread_mutex_unlock(&mutex)
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _H_MUTEX
diff --git a/common/ogl_ctx.c b/common/ogl_ctx.c
deleted file mode 100644
index 41c0591..0000000
--- a/common/ogl_ctx.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <X11/Xlib.h>
-#include <GL/glx.h>
-
-#include "ogl_ctx.h"
-#include "spice_common.h"
-
-enum {
- OGLCTX_TYPE_PBUF,
- OGLCTX_TYPE_PIXMAP,
-};
-
-struct OGLCtx {
- int type;
- Display *x_display;
- GLXContext glx_context;
- GLXDrawable drawable;
-};
-
-typedef struct OGLPixmapCtx {
- OGLCtx base;
- Pixmap pixmap;
-} OGLPixmapCtx;
-
-
-
-const char *oglctx_type_str(OGLCtx *ctx)
-{
- static const char *pbuf_str = "pbuf";
- static const char *pixmap_str = "pixmap";
- static const char *invalid_str = "invalid";
-
- switch (ctx->type) {
- case OGLCTX_TYPE_PBUF:
- return pbuf_str;
- case OGLCTX_TYPE_PIXMAP:
- return pixmap_str;
- default:
- return invalid_str;
- }
-}
-
-void oglctx_make_current(OGLCtx *ctx)
-{
- if (!glXMakeCurrent(ctx->x_display, ctx->drawable, ctx->glx_context)) {
- printf("%s: failed\n", __FUNCTION__);
- }
-}
-
-OGLCtx *pbuf_create(int width, int heigth)
-{
- OGLCtx *ctx;
- Display *x_display;
- int num_configs;
- GLXFBConfig *fb_config;
- GLXPbuffer glx_pbuf;
- GLXContext glx_context;
-
- const int glx_attributes[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT,
- GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
- GLX_RED_SIZE, 8,
- GLX_GREEN_SIZE, 8,
- GLX_BLUE_SIZE, 8,
- GLX_ALPHA_SIZE, 8,
- GLX_STENCIL_SIZE, 4,
- 0 };
-
- int pbuf_attrib[] = { GLX_PRESERVED_CONTENTS, True,
- GLX_PBUFFER_WIDTH, width,
- GLX_PBUFFER_HEIGHT, heigth,
- GLX_LARGEST_PBUFFER, False,
- 0, 0 };
-
- if (!(ctx = calloc(1, sizeof(*ctx)))) {
- printf("%s: alloc pbuf failed\n", __FUNCTION__);
- return NULL;
- }
-
- if (!(x_display = XOpenDisplay(NULL))) {
- printf("%s: open display failed\n", __FUNCTION__);
- goto error_1;
- }
-
- if (!(fb_config = glXChooseFBConfig(x_display, 0, glx_attributes, &num_configs)) ||
- !num_configs) {
- printf("%s: choose fb config failed\n", __FUNCTION__);
- goto error_2;
- }
-
- if (!(glx_pbuf = glXCreatePbuffer(x_display, fb_config[0], pbuf_attrib))) {
- goto error_3;
- }
-
- if (!(glx_context = glXCreateNewContext(x_display, fb_config[0], GLX_RGBA_TYPE, NULL, True))) {
- printf("%s: create context failed\n", __FUNCTION__);
- goto error_4;
- }
-
- XFree(fb_config);
-
- ctx->type = OGLCTX_TYPE_PBUF;
- ctx->drawable = glx_pbuf;
- ctx->glx_context = glx_context;
- ctx->x_display = x_display;
-
- return ctx;
-
-error_4:
- glXDestroyPbuffer(x_display, glx_pbuf);
-
-error_3:
- XFree(fb_config);
-
-error_2:
- XCloseDisplay(x_display);
-
-error_1:
- free(ctx);
-
- return NULL;
-}
-
-OGLCtx *pixmap_create(int width, int heigth)
-{
- Display *x_display;
- int num_configs;
- GLXFBConfig *fb_config;
- GLXPixmap glx_pixmap;
- GLXContext glx_context;
- Pixmap pixmap;
- int screen;
- Window root_window;
- OGLPixmapCtx *pix;
-
- const int glx_attributes[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT,
- GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
- GLX_RED_SIZE, 8,
- GLX_GREEN_SIZE, 8,
- GLX_BLUE_SIZE, 8,
- GLX_ALPHA_SIZE, 8,
- GLX_STENCIL_SIZE, 4,
- 0 };
-
- if (!(pix = calloc(1, sizeof(*pix)))) {
- printf("%s: alloc pix failed\n", __FUNCTION__);
- return NULL;
- }
-
- if (!(x_display = XOpenDisplay(NULL))) {
- printf("%s: open display failed\n", __FUNCTION__);
- goto error_1;
- }
-
- screen = DefaultScreen(x_display);
- root_window = RootWindow(x_display, screen);
-
- if (!(fb_config = glXChooseFBConfig(x_display, 0, glx_attributes, &num_configs)) ||
- !num_configs) {
- printf("%s: choose fb config failed\n", __FUNCTION__);
- goto error_2;
- }
-
- if (!(pixmap = XCreatePixmap(x_display, root_window, width, heigth, 32 /*use fb config*/))) {
- printf("%s: create x pixmap failed\n", __FUNCTION__);
- goto error_3;
- }
-
- if (!(glx_pixmap = glXCreatePixmap(x_display, fb_config[0], pixmap, NULL))) {
- printf("%s: create glx pixmap failed\n", __FUNCTION__);
- goto error_4;
- }
-
-
- if (!(glx_context = glXCreateNewContext(x_display, fb_config[0], GLX_RGBA_TYPE, NULL, True))) {
- printf("%s: create context failed\n", __FUNCTION__);
- goto error_5;
- }
-
- XFree(fb_config);
-
- pix->base.type = OGLCTX_TYPE_PIXMAP;
- pix->base.x_display = x_display;
- pix->base.drawable = glx_pixmap;
- pix->base.glx_context = glx_context;
- pix->pixmap = pixmap;
-
- return &pix->base;
-
-error_5:
- glXDestroyPixmap(x_display, glx_pixmap);
-
-error_4:
- XFreePixmap(x_display, pixmap);
-
-error_3:
- XFree(fb_config);
-
-error_2:
- XCloseDisplay(x_display);
-
-error_1:
- free(pix);
-
- return NULL;
-}
-
-void oglctx_destroy(OGLCtx *ctx)
-{
- if (!ctx) {
- return;
- }
- // test is current ?
-
- glXDestroyContext(ctx->x_display, ctx->glx_context);
- switch (ctx->type) {
- case OGLCTX_TYPE_PBUF:
- glXDestroyPbuffer(ctx->x_display, ctx->drawable);
- break;
- case OGLCTX_TYPE_PIXMAP:
- glXDestroyPixmap(ctx->x_display, ctx->drawable);
- XFreePixmap(ctx->x_display, ((OGLPixmapCtx *)ctx)->pixmap);
- break;
- default:
- PANIC("invalid ogl ctx type");
- }
-
- XCloseDisplay(ctx->x_display);
- free(ctx);
-}
diff --git a/common/ogl_ctx.h b/common/ogl_ctx.h
deleted file mode 100644
index e7f677a..0000000
--- a/common/ogl_ctx.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_GLCTX
-#define _H_GLCTX
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct OGLCtx OGLCtx;
-
-const char *oglctx_type_str(OGLCtx *ctx);
-void oglctx_make_current(OGLCtx *ctx);
-OGLCtx *pbuf_create(int width, int heigth);
-OGLCtx *pixmap_create(int width, int heigth);
-void oglctx_destroy(OGLCtx *ctx);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/pixman_utils.c b/common/pixman_utils.c
deleted file mode 100644
index 1136aa7..0000000
--- a/common/pixman_utils.c
+++ /dev/null
@@ -1,1594 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "pixman_utils.h"
-#include "spice_common.h"
-#include <spice/macros.h>
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include "mem.h"
-
-#define SOLID_RASTER_OP(_name, _size, _type, _equation) \
-static void \
-solid_rop_ ## _name ## _ ## _size (_type *ptr, int len, _type src) \
-{ \
- while (len--) { \
- _type dst = *ptr; \
- if (dst) /* avoid unused warning */{}; \
- *ptr = (_type)(_equation); \
- ptr++; \
- } \
-} \
-
-#define TILED_RASTER_OP(_name, _size, _type, _equation) \
-static void \
-tiled_rop_ ## _name ## _ ## _size (_type *ptr, int len, _type *tile, _type *tile_end, int tile_width) \
-{ \
- while (len--) { \
- _type src = *tile; \
- _type dst = *ptr; \
- if (src) /* avoid unused warning */{}; \
- if (dst) /* avoid unused warning */{}; \
- *ptr = (_type)(_equation); \
- ptr++; \
- tile++; \
- if (tile == tile_end) \
- tile -= tile_width; \
- } \
-} \
-
-#define COPY_RASTER_OP(_name, _size, _type, _equation) \
-static void \
- copy_rop_ ## _name ## _ ## _size (_type *ptr, _type *src_line, int len) \
-{ \
- while (len--) { \
- _type src = *src_line; \
- _type dst = *ptr; \
- if (src) /* avoid unused warning */ {}; \
- if (dst) /* avoid unused warning */{}; \
- *ptr = (_type)(_equation); \
- ptr++; \
- src_line++; \
- } \
-} \
-
-#define RASTER_OP(name, equation) \
- SOLID_RASTER_OP(name, 8, uint8_t, equation) \
- SOLID_RASTER_OP(name, 16, uint16_t, equation) \
- SOLID_RASTER_OP(name, 32, uint32_t, equation) \
- TILED_RASTER_OP(name, 8, uint8_t, equation) \
- TILED_RASTER_OP(name, 16, uint16_t, equation) \
- TILED_RASTER_OP(name, 32, uint32_t, equation) \
- COPY_RASTER_OP(name, 8, uint8_t, equation) \
- COPY_RASTER_OP(name, 16, uint16_t, equation) \
- COPY_RASTER_OP(name, 32, uint32_t, equation)
-
-RASTER_OP(clear, 0x0)
-RASTER_OP(and, src & dst)
-RASTER_OP(and_reverse, src & ~dst)
-RASTER_OP(copy, src)
-RASTER_OP(and_inverted, ~src & dst)
-RASTER_OP(noop, dst)
-RASTER_OP(xor, src ^ dst)
-RASTER_OP(or, src | dst)
-RASTER_OP(nor, ~src & ~dst)
-RASTER_OP(equiv, ~src ^ dst)
-RASTER_OP(invert, ~dst)
-RASTER_OP(or_reverse, src | ~dst)
-RASTER_OP(copy_inverted, ~src)
-RASTER_OP(or_inverted, ~src | dst)
-RASTER_OP(nand, ~src | ~dst)
-RASTER_OP(set, 0xffffffff)
-
-typedef void (*solid_rop_8_func_t)(uint8_t *ptr, int len, uint8_t src);
-typedef void (*solid_rop_16_func_t)(uint16_t *ptr, int len, uint16_t src);
-typedef void (*solid_rop_32_func_t)(uint32_t *ptr, int len, uint32_t src);
-typedef void (*tiled_rop_8_func_t)(uint8_t *ptr, int len,
- uint8_t *tile, uint8_t *tile_end, int tile_width);
-typedef void (*tiled_rop_16_func_t)(uint16_t *ptr, int len,
- uint16_t *tile, uint16_t *tile_end, int tile_width);
-typedef void (*tiled_rop_32_func_t)(uint32_t *ptr, int len,
- uint32_t *tile, uint32_t *tile_end, int tile_width);
-typedef void (*copy_rop_8_func_t)(uint8_t *ptr, uint8_t *src, int len);
-typedef void (*copy_rop_16_func_t)(uint16_t *ptr, uint16_t *src, int len);
-typedef void (*copy_rop_32_func_t)(uint32_t *ptr, uint32_t *src, int len);
-
-#define ROP_TABLE(_type, _size) \
-static void (*solid_rops_ ## _size[16]) (_type *ptr, int len, _type src) = { \
- solid_rop_clear_ ## _size, \
- solid_rop_and_ ## _size, \
- solid_rop_and_reverse_ ## _size, \
- solid_rop_copy_ ## _size, \
- solid_rop_and_inverted_ ## _size, \
- solid_rop_noop_ ## _size, \
- solid_rop_xor_ ## _size, \
- solid_rop_or_ ## _size, \
- solid_rop_nor_ ## _size, \
- solid_rop_equiv_ ## _size, \
- solid_rop_invert_ ## _size, \
- solid_rop_or_reverse_ ## _size, \
- solid_rop_copy_inverted_ ## _size, \
- solid_rop_or_inverted_ ## _size, \
- solid_rop_nand_ ## _size, \
- solid_rop_set_ ## _size \
-}; \
-static void (*tiled_rops_ ## _size[16]) (_type *ptr, int len, _type *tile, _type *tile_end, int tile_width) = { \
- tiled_rop_clear_ ## _size, \
- tiled_rop_and_ ## _size, \
- tiled_rop_and_reverse_ ## _size, \
- tiled_rop_copy_ ## _size, \
- tiled_rop_and_inverted_ ## _size, \
- tiled_rop_noop_ ## _size, \
- tiled_rop_xor_ ## _size, \
- tiled_rop_or_ ## _size, \
- tiled_rop_nor_ ## _size, \
- tiled_rop_equiv_ ## _size, \
- tiled_rop_invert_ ## _size, \
- tiled_rop_or_reverse_ ## _size, \
- tiled_rop_copy_inverted_ ## _size, \
- tiled_rop_or_inverted_ ## _size, \
- tiled_rop_nand_ ## _size, \
- tiled_rop_set_ ## _size \
-}; \
-static void (*copy_rops_ ## _size[16]) (_type *ptr, _type *tile, int len) = { \
- copy_rop_clear_ ## _size, \
- copy_rop_and_ ## _size, \
- copy_rop_and_reverse_ ## _size, \
- copy_rop_copy_ ## _size, \
- copy_rop_and_inverted_ ## _size, \
- copy_rop_noop_ ## _size, \
- copy_rop_xor_ ## _size, \
- copy_rop_or_ ## _size, \
- copy_rop_nor_ ## _size, \
- copy_rop_equiv_ ## _size, \
- copy_rop_invert_ ## _size, \
- copy_rop_or_reverse_ ## _size, \
- copy_rop_copy_inverted_ ## _size, \
- copy_rop_or_inverted_ ## _size, \
- copy_rop_nand_ ## _size, \
- copy_rop_set_ ## _size \
-};
-
-ROP_TABLE(uint8_t, 8)
-ROP_TABLE(uint16_t, 16)
-ROP_TABLE(uint32_t, 32)
-
-/* We can't get the real bits per pixel info from pixman_image_t,
- only the DEPTH which is the sum of all a+r+g+b bits, which
- is e.g. 24 for 32bit xRGB. We really want the bpp, so
- we have this ugly conversion thing */
-int spice_pixman_image_get_bpp(pixman_image_t *image)
-{
- int depth;
-
- depth = pixman_image_get_depth(image);
- if (depth == 24) {
- return 32;
- }
- if (depth == 15) {
- return 16;
- }
- return depth;
-}
-
-void spice_pixman_fill_rect(pixman_image_t *dest,
- int x, int y,
- int width, int height,
- uint32_t value)
-{
- uint32_t *bits;
- int stride, depth;
- uint32_t byte_width;
- uint8_t *byte_line;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- ASSERT(x >= 0);
- ASSERT(y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(x + width <= pixman_image_get_width(dest));
- ASSERT(y + height <= pixman_image_get_height(dest));
-
- if (pixman_fill(bits,
- stride / 4,
- depth,
- x, y,
- width, height,
- value)) {
- return;
- }
-
- if (depth == 8) {
- byte_line = ((uint8_t *)bits) + stride * y + x;
- byte_width = width;
- value = (value & 0xff) * 0x01010101;
- } else if (depth == 16) {
- byte_line = ((uint8_t *)bits) + stride * y + x * 2;
- byte_width = 2 * width;
- value = (value & 0xffff) * 0x00010001;
- } else {
- ASSERT (depth == 32)
- byte_line = ((uint8_t *)bits) + stride * y + x * 4;
- byte_width = 4 * width;
- }
-
- while (height--) {
- int w;
- uint8_t *d = byte_line;
-
- byte_line += stride;
- w = byte_width;
-
- while (w >= 1 && ((uintptr_t)d & 1)) {
- *(uint8_t *)d = (value & 0xff);
- w--;
- d++;
- }
-
- while (w >= 2 && ((uintptr_t)d & 3)) {
- *(uint16_t *)d = value;
- w -= 2;
- d += 2;
- }
-
- while (w >= 4 && ((uintptr_t)d & 7)) {
- *(uint32_t *)d = value;
-
- w -= 4;
- d += 4;
- }
-
- while (w >= 4) {
- *(uint32_t *)d = value;
-
- w -= 4;
- d += 4;
- }
-
- while (w >= 2) {
- *(uint16_t *)d = value;
- w -= 2;
- d += 2;
- }
-
- while (w >= 1) {
- *(uint8_t *)d = (value & 0xff);
- w--;
- d++;
- }
- }
-}
-
-void spice_pixman_fill_rect_rop(pixman_image_t *dest,
- int x, int y,
- int width, int height,
- uint32_t value,
- SpiceROP rop)
-{
- uint32_t *bits;
- int stride, depth;
- uint8_t *byte_line;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- ASSERT(x >= 0);
- ASSERT(y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(x + width <= pixman_image_get_width(dest));
- ASSERT(y + height <= pixman_image_get_height(dest));
- ASSERT(rop >= 0 && rop < 16);
-
- if (depth == 8) {
- solid_rop_8_func_t rop_func = solid_rops_8[rop];
-
- byte_line = ((uint8_t *)bits) + stride * y + x;
- while (height--) {
- rop_func((uint8_t *)byte_line, width, (uint8_t)value);
- byte_line += stride;
- }
-
- } else if (depth == 16) {
- solid_rop_16_func_t rop_func = solid_rops_16[rop];
-
- byte_line = ((uint8_t *)bits) + stride * y + x * 2;
- while (height--) {
- rop_func((uint16_t *)byte_line, width, (uint16_t)value);
- byte_line += stride;
- }
- } else {
- solid_rop_32_func_t rop_func = solid_rops_32[rop];
-
- byte_line = ((uint8_t *)bits) + stride * y + x * 4;
- while (height--) {
- rop_func((uint32_t *)byte_line, width, (uint32_t)value);
- byte_line += stride;
- }
- }
-}
-
-void spice_pixman_tile_rect(pixman_image_t *dest,
- int x, int y,
- int width, int height,
- pixman_image_t *tile,
- int offset_x,
- int offset_y)
-{
- uint32_t *bits, *tile_bits;
- int stride, depth;
- int tile_width, tile_height, tile_stride;
- uint8_t *byte_line;
- uint8_t *tile_line;
- int tile_start_x, tile_start_y, tile_end_dx;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- tile_bits = pixman_image_get_data(tile);
- tile_stride = pixman_image_get_stride(tile);
- tile_width = pixman_image_get_width(tile);
- tile_height = pixman_image_get_height(tile);
-
- ASSERT(x >= 0);
- ASSERT(y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(x + width <= pixman_image_get_width(dest));
- ASSERT(y + height <= pixman_image_get_height(dest));
- ASSERT(depth == spice_pixman_image_get_bpp(tile));
-
- tile_start_x = (x - offset_x) % tile_width;
- if (tile_start_x < 0) {
- tile_start_x += tile_width;
- }
- tile_start_y = (y - offset_y) % tile_height;
- if (tile_start_y < 0) {
- tile_start_y += tile_height;
- }
- tile_end_dx = tile_width - tile_start_x;
-
- if (depth == 8) {
- byte_line = ((uint8_t *)bits) + stride * y + x;
- tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x;
- while (height--) {
- tiled_rop_copy_8((uint8_t *)byte_line, width,
- (uint8_t *)tile_line, (uint8_t *)tile_line + tile_end_dx,
- tile_width);
- byte_line += stride;
- tile_line += tile_stride;
- if (++tile_start_y == tile_height) {
- tile_line -= tile_height * tile_stride;
- tile_start_y = 0;
- }
- }
-
- } else if (depth == 16) {
- byte_line = ((uint8_t *)bits) + stride * y + x * 2;
- tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x * 2;
- while (height--) {
- tiled_rop_copy_16((uint16_t *)byte_line, width,
- (uint16_t *)tile_line, (uint16_t *)tile_line + tile_end_dx,
- tile_width);
- byte_line += stride;
- tile_line += tile_stride;
- if (++tile_start_y == tile_height) {
- tile_line -= tile_height * tile_stride;
- tile_start_y = 0;
- }
- }
- } else {
- ASSERT (depth == 32);
-
- byte_line = ((uint8_t *)bits) + stride * y + x * 4;
- tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x * 4;
- while (height--) {
- tiled_rop_copy_32((uint32_t *)byte_line, width,
- (uint32_t *)tile_line, (uint32_t *)tile_line + tile_end_dx,
- tile_width);
- byte_line += stride;
- tile_line += tile_stride;
- if (++tile_start_y == tile_height) {
- tile_line -= tile_height * tile_stride;
- tile_start_y = 0;
- }
- }
- }
-}
-
-void spice_pixman_tile_rect_rop(pixman_image_t *dest,
- int x, int y,
- int width, int height,
- pixman_image_t *tile,
- int offset_x,
- int offset_y,
- SpiceROP rop)
-{
- uint32_t *bits, *tile_bits;
- int stride, depth;
- int tile_width, tile_height, tile_stride;
- uint8_t *byte_line;
- uint8_t *tile_line;
- int tile_start_x, tile_start_y, tile_end_dx;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- tile_bits = pixman_image_get_data(tile);
- tile_stride = pixman_image_get_stride(tile);
- tile_width = pixman_image_get_width(tile);
- tile_height = pixman_image_get_height(tile);
-
- ASSERT(x >= 0);
- ASSERT(y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(x + width <= pixman_image_get_width(dest));
- ASSERT(y + height <= pixman_image_get_height(dest));
- ASSERT(rop >= 0 && rop < 16);
- ASSERT(depth == spice_pixman_image_get_bpp(tile));
-
- tile_start_x = (x - offset_x) % tile_width;
- if (tile_start_x < 0) {
- tile_start_x += tile_width;
- }
- tile_start_y = (y - offset_y) % tile_height;
- if (tile_start_y < 0) {
- tile_start_y += tile_height;
- }
- tile_end_dx = tile_width - tile_start_x;
-
- if (depth == 8) {
- tiled_rop_8_func_t rop_func = tiled_rops_8[rop];
-
- byte_line = ((uint8_t *)bits) + stride * y + x;
- tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x;
- while (height--) {
- rop_func((uint8_t *)byte_line, width,
- (uint8_t *)tile_line, (uint8_t *)tile_line + tile_end_dx,
- tile_width);
- byte_line += stride;
- tile_line += tile_stride;
- if (++tile_start_y == tile_height) {
- tile_line -= tile_height * tile_stride;
- tile_start_y = 0;
- }
- }
-
- } else if (depth == 16) {
- tiled_rop_16_func_t rop_func = tiled_rops_16[rop];
-
- byte_line = ((uint8_t *)bits) + stride * y + x * 2;
- tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x * 2;
- while (height--) {
- rop_func((uint16_t *)byte_line, width,
- (uint16_t *)tile_line, (uint16_t *)tile_line + tile_end_dx,
- tile_width);
- byte_line += stride;
- tile_line += tile_stride;
- if (++tile_start_y == tile_height) {
- tile_line -= tile_height * tile_stride;
- tile_start_y = 0;
- }
- }
- } else {
- tiled_rop_32_func_t rop_func = tiled_rops_32[rop];
-
- ASSERT (depth == 32);
-
- byte_line = ((uint8_t *)bits) + stride * y + x * 4;
- tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x * 4;
- while (height--) {
- rop_func((uint32_t *)byte_line, width,
- (uint32_t *)tile_line, (uint32_t *)tile_line + tile_end_dx,
- tile_width);
- byte_line += stride;
- tile_line += tile_stride;
- if (++tile_start_y == tile_height) {
- tile_line -= tile_height * tile_stride;
- tile_start_y = 0;
- }
- }
- }
-}
-
-
-void spice_pixman_blit(pixman_image_t *dest,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height)
-{
- uint32_t *bits, *src_bits;
- int stride, depth, src_depth;
- int src_width, src_height, src_stride;
- uint8_t *byte_line;
- uint8_t *src_line;
- int byte_width;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- src_bits = pixman_image_get_data(src);
- src_stride = pixman_image_get_stride(src);
- src_width = pixman_image_get_width(src);
- src_height = pixman_image_get_height(src);
- src_depth = spice_pixman_image_get_bpp(src);
-
- /* Clip source */
- if (src_x < 0) {
- width += src_x;
- dest_x -= src_x;
- src_x = 0;
- }
- if (src_y < 0) {
- height += src_y;
- dest_y -= src_y;
- src_y = 0;
- }
- if (src_x + width > src_width) {
- width = src_width - src_x;
- }
- if (src_y + height > src_height) {
- height = src_height - src_y;
- }
-
- if (width <= 0 || height <= 0) {
- return;
- }
-
- ASSERT(src_x >= 0);
- ASSERT(src_y >= 0);
- ASSERT(dest_x >= 0);
- ASSERT(dest_y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(dest_x + width <= pixman_image_get_width(dest));
- ASSERT(dest_y + height <= pixman_image_get_height(dest));
- ASSERT(src_x + width <= pixman_image_get_width(src));
- ASSERT(src_y + height <= pixman_image_get_height(src));
- ASSERT(depth == src_depth);
-
- if (pixman_blt(src_bits,
- bits,
- src_stride / 4,
- stride / 4,
- depth, depth,
- src_x, src_y,
- dest_x, dest_y,
- width, height)) {
- return;
- }
-
- if (depth == 8) {
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x;
- byte_width = width;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x;
- } else if (depth == 16) {
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 2;
- byte_width = width * 2;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 2;
- } else {
- ASSERT (depth == 32);
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 4;
- byte_width = width * 4;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 4;
- }
-
- while (height--) {
- memcpy(byte_line, src_line, byte_width);
- byte_line += stride;
- src_line += src_stride;
- }
-}
-
-void spice_pixman_blit_rop (pixman_image_t *dest,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- SpiceROP rop)
-{
- uint32_t *bits, *src_bits;
- int stride, depth, src_depth;
- int src_width, src_height, src_stride;
- uint8_t *byte_line;
- uint8_t *src_line;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- src_bits = pixman_image_get_data(src);
- src_stride = pixman_image_get_stride(src);
- src_width = pixman_image_get_width(src);
- src_height = pixman_image_get_height(src);
- src_depth = spice_pixman_image_get_bpp(src);
-
- /* Clip source */
- if (src_x < 0) {
- width += src_x;
- dest_x -= src_x;
- src_x = 0;
- }
- if (src_y < 0) {
- height += src_y;
- dest_y -= src_y;
- src_y = 0;
- }
- if (src_x + width > src_width) {
- width = src_width - src_x;
- }
- if (src_y + height > src_height) {
- height = src_height - src_y;
- }
-
- if (width <= 0 || height <= 0) {
- return;
- }
-
- ASSERT(src_x >= 0);
- ASSERT(src_y >= 0);
- ASSERT(dest_x >= 0);
- ASSERT(dest_y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(dest_x + width <= pixman_image_get_width(dest));
- ASSERT(dest_y + height <= pixman_image_get_height(dest));
- ASSERT(src_x + width <= pixman_image_get_width(src));
- ASSERT(src_y + height <= pixman_image_get_height(src));
- ASSERT(depth == src_depth);
-
- if (depth == 8) {
- copy_rop_8_func_t rop_func = copy_rops_8[rop];
-
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x;
-
- while (height--) {
- rop_func((uint8_t *)byte_line, (uint8_t *)src_line, width);
- byte_line += stride;
- src_line += src_stride;
- }
- } else if (depth == 16) {
- copy_rop_16_func_t rop_func = copy_rops_16[rop];
-
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 2;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 2;
-
- while (height--) {
- rop_func((uint16_t *)byte_line, (uint16_t *)src_line, width);
- byte_line += stride;
- src_line += src_stride;
- }
- } else {
- copy_rop_32_func_t rop_func = copy_rops_32[rop];
-
- ASSERT (depth == 32);
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 4;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 4;
-
- while (height--) {
- rop_func((uint32_t *)byte_line, (uint32_t *)src_line, width);
- byte_line += stride;
- src_line += src_stride;
- }
- }
-
-}
-
-void spice_pixman_blit_colorkey (pixman_image_t *dest,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- uint32_t transparent_color)
-{
- uint32_t *bits, *src_bits;
- int stride, depth;
- int src_width, src_height, src_stride;
- uint8_t *byte_line;
- uint8_t *src_line;
- int x;
-
- bits = pixman_image_get_data(dest);
- stride = pixman_image_get_stride(dest);
- depth = spice_pixman_image_get_bpp(dest);
- /* stride is in bytes, depth in bits */
-
- src_bits = pixman_image_get_data(src);
- src_stride = pixman_image_get_stride(src);
- src_width = pixman_image_get_width(src);
- src_height = pixman_image_get_height(src);
-
- /* Clip source */
- if (src_x < 0) {
- width += src_x;
- dest_x -= src_x;
- src_x = 0;
- }
- if (src_y < 0) {
- height += src_y;
- dest_y -= src_y;
- src_y = 0;
- }
- if (src_x + width > src_width) {
- width = src_width - src_x;
- }
- if (src_y + height > src_height) {
- height = src_height - src_y;
- }
-
- if (width <= 0 || height <= 0) {
- return;
- }
-
- ASSERT(src_x >= 0);
- ASSERT(src_y >= 0);
- ASSERT(dest_x >= 0);
- ASSERT(dest_y >= 0);
- ASSERT(width > 0);
- ASSERT(height > 0);
- ASSERT(dest_x + width <= pixman_image_get_width(dest));
- ASSERT(dest_y + height <= pixman_image_get_height(dest));
- ASSERT(src_x + width <= pixman_image_get_width(src));
- ASSERT(src_y + height <= pixman_image_get_height(src));
- ASSERT(depth == spice_pixman_image_get_bpp(src));
-
- if (depth == 8) {
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x;
-
- while (height--) {
- uint8_t *d = (uint8_t *)byte_line;
- uint8_t *s = (uint8_t *)src_line;
- for (x = 0; x < width; x++) {
- uint8_t val = *s;
- if (val != (uint8_t)transparent_color) {
- *d = val;
- }
- s++; d++;
- }
-
- byte_line += stride;
- src_line += src_stride;
- }
- } else if (depth == 16) {
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 2;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 2;
-
- while (height--) {
- uint16_t *d = (uint16_t *)byte_line;
- uint16_t *s = (uint16_t *)src_line;
-
- for (x = 0; x < width; x++) {
- uint16_t val = *s;
- if (val != (uint16_t)transparent_color) {
- *d = val;
- }
- s++; d++;
- }
-
- byte_line += stride;
- src_line += src_stride;
- }
- } else {
- ASSERT (depth == 32);
- byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 4;
- src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 4;
-
- while (height--) {
- uint32_t *d = (uint32_t *)byte_line;
- uint32_t *s = (uint32_t *)src_line;
-
- transparent_color &= 0xffffff;
- for (x = 0; x < width; x++) {
- uint32_t val = *s;
- if ((0xffffff & val) != transparent_color) {
- *d = val;
- }
- s++; d++;
- }
-
- byte_line += stride;
- src_line += src_stride;
- }
- }
-}
-
-static void copy_bits_up(uint8_t *data, const int stride, int bpp,
- 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 * bpp;
- uint8_t *dest = data + dest_y * stride + dest_x * bpp;
- uint8_t *end = dest + height * stride;
- for (; dest != end; dest += stride, src += stride) {
- memcpy(dest, src, width * bpp);
- }
-}
-
-static void copy_bits_down(uint8_t *data, const int stride, int bpp,
- 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 * bpp;
- uint8_t *end = data + (dest_y - 1) * stride + dest_x * bpp;
- uint8_t *dest = end + height * stride;
-
- for (; dest != end; dest -= stride, src -= stride) {
- memcpy(dest, src, width * bpp);
- }
-}
-
-static void copy_bits_same_line(uint8_t *data, const int stride, int bpp,
- 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 * bpp;
- uint8_t *dest = data + dest_y * stride + dest_x * bpp;
- uint8_t *end = dest + height * stride;
- for (; dest != end; dest += stride, src += stride) {
- memmove(dest, src, width * bpp);
- }
-}
-
-void spice_pixman_copy_rect (pixman_image_t *image,
- int src_x, int src_y,
- int width, int height,
- int dest_x, int dest_y)
-{
- uint8_t *data;
- int stride;
- int bpp;
-
- data = (uint8_t *)pixman_image_get_data(image);
- stride = pixman_image_get_stride(image);
- bpp = spice_pixman_image_get_bpp(image) / 8;
-
- if (dest_y > src_y) {
- copy_bits_down(data, stride, bpp,
- src_x, src_y,
- width, height,
- dest_x, dest_y);
- } else if (dest_y < src_y) {
- copy_bits_up(data, stride, bpp,
- src_x, src_y,
- width, height,
- dest_x, dest_y);
- } else {
- copy_bits_same_line(data, stride, bpp,
- src_x, src_y,
- width, height,
- dest_x, dest_y);
- }
-}
-
-pixman_bool_t spice_pixman_region32_init_rects (pixman_region32_t *region,
- const SpiceRect *rects,
- int count)
-{
- /* These types are compatible, so just cast */
- return pixman_region32_init_rects(region, (pixman_box32_t *)rects, count);
-}
-
-pixman_format_code_t spice_surface_format_to_pixman(uint32_t surface_format)
-{
- switch (surface_format) {
- case SPICE_SURFACE_FMT_1_A:
- return PIXMAN_a1;
- case SPICE_SURFACE_FMT_8_A:
- return PIXMAN_a8;
- case SPICE_SURFACE_FMT_16_555:
- return PIXMAN_x1r5g5b5;
- case SPICE_SURFACE_FMT_16_565:
- return PIXMAN_r5g6b5;
- case SPICE_SURFACE_FMT_32_xRGB:
- return PIXMAN_x8r8g8b8;
- case SPICE_SURFACE_FMT_32_ARGB:
- return PIXMAN_a8r8g8b8;
- default:
- printf("Unknown surface format %d\n", surface_format);
- abort();
- break;
- }
- return (pixman_format_code_t)0; /* Not reached */
-}
-
-/* Returns the "spice native" pixman version of a specific bitmap format.
- * This isn't bitwise the same as the bitmap format, for instance we
- * typically convert indexed to real color modes and use the standard
- * surface modes rather than weird things like 24bit
- */
-pixman_format_code_t spice_bitmap_format_to_pixman(int bitmap_format,
- uint32_t palette_surface_format)
-{
- switch (bitmap_format) {
- case SPICE_BITMAP_FMT_1BIT_LE:
- case SPICE_BITMAP_FMT_1BIT_BE:
- case SPICE_BITMAP_FMT_4BIT_LE:
- case SPICE_BITMAP_FMT_4BIT_BE:
- case SPICE_BITMAP_FMT_8BIT:
- /* Indexed mode palettes are the same as their destination canvas format */
- return spice_surface_format_to_pixman(palette_surface_format);
-
- case SPICE_BITMAP_FMT_16BIT:
- return PIXMAN_x1r5g5b5;
-
- case SPICE_BITMAP_FMT_24BIT:
- case SPICE_BITMAP_FMT_32BIT:
- return PIXMAN_x8r8g8b8;
-
- case SPICE_BITMAP_FMT_RGBA:
- return PIXMAN_a8r8g8b8;
-
- case SPICE_BITMAP_FMT_INVALID:
- default:
- printf("Unknown bitmap format %d\n", bitmap_format);
- abort();
- return PIXMAN_a8r8g8b8;
- }
-}
-
-/* Tries to view a spice bitmap as a pixman_image_t without copying,
- * will often fail due to unhandled formats or strides.
- */
-pixman_image_t *spice_bitmap_try_as_pixman(int src_format,
- int flags,
- int width,
- int height,
- uint8_t *data,
- int stride)
-{
- pixman_format_code_t pixman_format;
-
- /* Pixman stride must be multiple of 4 */
- if (stride % 4 != 0) {
- return NULL;
- }
-
- switch (src_format) {
- case SPICE_BITMAP_FMT_32BIT:
-#ifdef WORDS_BIGENDIAN
- pixman_format = PIXMAN_b8g8r8x8;
-#else
- pixman_format = PIXMAN_x8r8g8b8;
-#endif
- break;
- case SPICE_BITMAP_FMT_RGBA:
-#ifdef WORDS_BIGENDIAN
- pixman_format = PIXMAN_b8g8r8a8;
-#else
- pixman_format = PIXMAN_a8r8g8b8;
-#endif
- break;
- case SPICE_BITMAP_FMT_24BIT:
-#ifdef WORDS_BIGENDIAN
- pixman_format = PIXMAN_b8g8r8;
-#else
- pixman_format = PIXMAN_r8g8b8;
-#endif
- break;
- case SPICE_BITMAP_FMT_16BIT:
-#ifdef WORDS_BIGENDIAN
- return NULL;
-#else
- pixman_format = PIXMAN_x1r5g5b5;
-#endif
- break;
-
- default:
- return NULL;
- }
-
- if (!(flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
- data += stride * (height - 1);
- stride = -stride;
- }
-
- return pixman_image_create_bits (pixman_format,
- width,
- height,
- (uint32_t *)data,
- stride);
-}
-
-#ifdef WORDS_BIGENDIAN
-#define UINT16_FROM_LE(x) SPICE_BYTESWAP16(x)
-#define UINT32_FROM_LE(x) SPICE_BYTESWAP32(x)
-#else
-#define UINT16_FROM_LE(x) (x)
-#define UINT32_FROM_LE(x) (x)
-#endif
-
-static INLINE uint32_t rgb_16_555_to_32(uint16_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 uint16_t rgb_32_to_16_555(uint32_t color)
-{
- return
- (((color) >> 3) & 0x001f) |
- (((color) >> 6) & 0x03e0) |
- (((color) >> 9) & 0x7c00);
-}
-
-
-static void bitmap_32_to_32(uint8_t* dest, int dest_stride,
- uint8_t* src, int src_stride,
- int width, uint8_t* end)
-{
-#ifdef WORDS_BIGENDIAN
- 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;
-
- for (; src_line < src_line_end; ++dest_line, ++src_line) {
- *dest_line = UINT32_FROM_LE(*src_line);
- }
- }
-#else
- for (; src != end; src += src_stride, dest += dest_stride) {
- memcpy(dest, src, width * 4);
- }
-#endif
-}
-
-static void bitmap_24_to_32(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;
- uint32_t* dest_line = (uint32_t *)dest;
-
- for (; src_line < src_line_end; ++dest_line) {
- uint32_t r, g, b;
- b = *(src_line++);
- g = *(src_line++);
- r = *(src_line++);
- *dest_line = (r << 16) | (g << 8) | (b);
- }
- }
-}
-
-static void bitmap_16_to_16_555(uint8_t* dest, int dest_stride,
- uint8_t* src, int src_stride,
- int width, uint8_t* end)
-{
-#ifdef WORDS_BIGENDIAN
- for (; src != end; src += src_stride, dest += dest_stride) {
- uint16_t* src_line = (uint16_t *)src;
- uint16_t* src_line_end = src_line + width;
- uint16_t* dest_line = (uint16_t *)dest;
-
- for (; src_line < src_line_end; ++dest_line, ++src_line) {
- *dest_line = UINT16_FROM_LE(*src_line);
- }
- }
-#else
- for (; src != end; src += src_stride, dest += dest_stride) {
- memcpy(dest, src, width * 2);
- }
-#endif
-}
-
-static void bitmap_8_32_to_32(uint8_t *dest, int dest_stride,
- uint8_t *src, int src_stride,
- int width, uint8_t *end,
- SpicePalette *palette)
-{
- uint32_t local_ents[256];
- uint32_t *ents;
- int n_ents;
-#ifdef WORDS_BIGENDIAN
- int i;
-#endif
-
- if (!palette) {
- PANIC("No palette");
- return;
- }
-
- n_ents = MIN(palette->num_ents, 256);
- ents = palette->ents;
-
- if (n_ents < 255
-#ifdef WORDS_BIGENDIAN
- || TRUE
-#endif
- ) {
- memcpy(local_ents, ents, n_ents*4);
- ents = local_ents;
-
-#ifdef WORDS_BIGENDIAN
- for (i = 0; i < n_ents; i++) {
- ents[i] = UINT32_FROM_LE(ents[i]);
- }
-#endif
- }
-
- 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) {
- *(dest_line++) = ents[*(src_line++)];
- }
- }
-}
-
-static void bitmap_8_16_to_16_555(uint8_t *dest, int dest_stride,
- uint8_t *src, int src_stride,
- int width, uint8_t *end,
- SpicePalette *palette)
-{
- uint32_t local_ents[256];
- uint32_t *ents;
- int n_ents;
-#ifdef WORDS_BIGENDIAN
- int i;
-#endif
-
- if (!palette) {
- PANIC("No palette");
- return;
- }
-
- n_ents = MIN(palette->num_ents, 256);
- ents = palette->ents;
-
- if (n_ents < 255
-#ifdef WORDS_BIGENDIAN
- || TRUE
-#endif
- ) {
- memcpy(local_ents, ents, n_ents*4);
- ents = local_ents;
-
-#ifdef WORDS_BIGENDIAN
- for (i = 0; i < n_ents; i++) {
- ents[i] = UINT32_FROM_LE(ents[i]);
- }
-#endif
- }
-
- for (; src != end; src += src_stride, dest += dest_stride) {
- uint16_t *dest_line = (uint16_t*)dest;
- uint8_t *src_line = src;
- uint8_t *src_line_end = src_line + width;
-
- while (src_line < src_line_end) {
- *(dest_line++) = ents[*(src_line++)];
- }
- }
-}
-
-static void bitmap_4be_32_to_32(uint8_t* dest, int dest_stride,
- uint8_t* src, int src_stride,
- int width, uint8_t* end,
- SpicePalette *palette)
-{
- uint32_t local_ents[16];
- uint32_t *ents;
- int n_ents;
-#ifdef WORDS_BIGENDIAN
- int i;
-#endif
-
- if (!palette) {
- PANIC("No palette");
- return;
- }
-
- n_ents = MIN(palette->num_ents, 16);
- ents = palette->ents;
-
- if (n_ents < 16
-#ifdef WORDS_BIGENDIAN
- || TRUE
-#endif
- ) {
- memcpy(local_ents, ents, n_ents*4);
- ents = local_ents;
-
-#ifdef WORDS_BIGENDIAN
- for (i = 0; i < n_ents; i++) {
- ents[i] = UINT32_FROM_LE(ents[i]);
- }
-#endif
- }
-
- for (; src != end; src += src_stride, dest += dest_stride) {
- uint32_t *dest_line = (uint32_t *)dest;
- uint8_t *row = src;
- int i;
-
- for (i = 0; i < (width >> 1); i++) {
- *(dest_line++) = ents[(*row >> 4) & 0x0f];
- *(dest_line++) = ents[*(row++) & 0x0f];
- }
- if (width & 1) {
- *(dest_line) = ents[(*row >> 4) & 0x0f];
- }
- }
-}
-
-static void bitmap_4be_16_to_16_555(uint8_t* dest, int dest_stride,
- uint8_t* src, int src_stride,
- int width, uint8_t* end,
- SpicePalette *palette)
-{
- uint32_t local_ents[16];
- uint32_t *ents;
- int n_ents;
-#ifdef WORDS_BIGENDIAN
- int i;
-#endif
-
- if (!palette) {
- PANIC("No palette");
- return;
- }
-
- n_ents = MIN(palette->num_ents, 16);
- ents = palette->ents;
-
- if (n_ents < 16
-#ifdef WORDS_BIGENDIAN
- || TRUE
-#endif
- ) {
- memcpy(local_ents, ents, n_ents*4);
- ents = local_ents;
-
-#ifdef WORDS_BIGENDIAN
- for (i = 0; i < n_ents; i++) {
- ents[i] = UINT32_FROM_LE(ents[i]);
- }
-#endif
- }
-
- for (; src != end; src += src_stride, dest += dest_stride) {
- uint16_t *dest_line = (uint16_t *)dest;
- uint8_t *row = src;
- int i;
-
- for (i = 0; i < (width >> 1); i++) {
- *(dest_line++) = ents[(*row >> 4) & 0x0f];
- *(dest_line++) = ents[*(row++) & 0x0f];
- }
- if (width & 1) {
- *(dest_line) = ents[(*row >> 4) & 0x0f];
- }
- }
-}
-
-static INLINE int test_bit_be(void* addr, int bit)
-{
- return !!(((uint8_t*)addr)[bit >> 3] & (0x80 >> (bit & 0x07)));
-}
-
-static void bitmap_1be_32_to_32(uint8_t* dest, int dest_stride,
- uint8_t* src, int src_stride,
- int width, uint8_t* end,
- SpicePalette *palette)
-{
- uint32_t fore_color;
- uint32_t back_color;
-
- ASSERT(palette != NULL);
-
- if (!palette) {
- return;
- }
-
- fore_color = UINT32_FROM_LE(palette->ents[1]);
- back_color = UINT32_FROM_LE(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 void bitmap_1be_16_to_16_555(uint8_t* dest, int dest_stride,
- uint8_t* src, int src_stride,
- int width, uint8_t* end,
- SpicePalette *palette)
-{
- uint16_t fore_color;
- uint16_t back_color;
-
- ASSERT(palette != NULL);
-
- if (!palette) {
- return;
- }
-
- fore_color = (uint16_t) UINT32_FROM_LE(palette->ents[1]);
- back_color = (uint16_t) UINT32_FROM_LE(palette->ents[0]);
-
- for (; src != end; src += src_stride, dest += dest_stride) {
- uint16_t* dest_line = (uint16_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;
- }
- }
- }
-}
-
-#ifdef NOT_USED_ATM
-
-static void bitmap_16_to_32(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 = rgb_16_555_to_32(UINT16_FROM_LE(*src_line));
- }
- }
-}
-
-static void bitmap_32_to_16_555(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;
- uint16_t* dest_line = (uint16_t *)dest;
-
- for (; src_line < src_line_end; ++dest_line, ++src_line) {
- *dest_line = rgb_32_to_16_555(UINT16_FROM_LE(*src_line));
- }
- }
-}
-
-
-static void bitmap_24_to_16_555(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;
- uint16_t* dest_line = (uint16_t *)dest;
-
- for (; src_line < src_line_end; ++dest_line) {
- uint8_t r, g, b;
- b = *(src_line++);
- g = *(src_line++);
- r = *(src_line++);
- *dest_line = rgb_32_to_16_555(r << 24 | g << 16 | b);
- }
- }
-}
-
-#endif
-
-/* This assumes that the dest, if set is the same format as
- spice_bitmap_format_to_pixman would have picked */
-pixman_image_t *spice_bitmap_to_pixman(pixman_image_t *dest_image,
- int src_format,
- int flags,
- int width,
- int height,
- uint8_t *src,
- int src_stride,
- uint32_t palette_surface_format,
- SpicePalette *palette)
-{
- uint8_t* dest;
- int dest_stride;
- uint8_t* end;
-
- if (dest_image == NULL) {
- pixman_format_code_t dest_format;
-
- dest_format = spice_bitmap_format_to_pixman(src_format,
- palette_surface_format);
- dest_image = pixman_image_create_bits (dest_format,
- width, height,
- NULL, 0);
- }
-
- dest = (uint8_t *)pixman_image_get_data(dest_image);
- dest_stride = pixman_image_get_stride(dest_image);
- if (!(flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
- ASSERT(height > 0);
- dest += dest_stride * (height - 1);
- dest_stride = -dest_stride;
- }
- end = src + (height * src_stride);
-
- switch (src_format) {
- case SPICE_BITMAP_FMT_32BIT:
- case SPICE_BITMAP_FMT_RGBA:
- bitmap_32_to_32(dest, dest_stride, src, src_stride, width, end);
- break;
- case SPICE_BITMAP_FMT_24BIT:
- bitmap_24_to_32(dest, dest_stride, src, src_stride, width, end);
- break;
- case SPICE_BITMAP_FMT_16BIT:
- bitmap_16_to_16_555(dest, dest_stride, src, src_stride, width, end);
- break;
- case SPICE_BITMAP_FMT_8BIT:
- if (palette_surface_format == SPICE_SURFACE_FMT_32_ARGB ||
- palette_surface_format == SPICE_SURFACE_FMT_32_xRGB) {
- bitmap_8_32_to_32(dest, dest_stride, src, src_stride, width, end, palette);
- } else if (palette_surface_format == SPICE_SURFACE_FMT_16_555) {
- bitmap_8_16_to_16_555(dest, dest_stride, src, src_stride, width, end, palette);
- } else {
- PANIC("Unsupported palette format");
- }
- break;
- case SPICE_BITMAP_FMT_4BIT_BE:
- if (palette_surface_format == SPICE_SURFACE_FMT_32_ARGB ||
- palette_surface_format == SPICE_SURFACE_FMT_32_xRGB) {
- bitmap_4be_32_to_32(dest, dest_stride, src, src_stride, width, end, palette);
- } else if (palette_surface_format == SPICE_SURFACE_FMT_16_555) {
- bitmap_4be_16_to_16_555(dest, dest_stride, src, src_stride, width, end, palette);
- } else {
- PANIC("Unsupported palette format");
- }
- break;
- case SPICE_BITMAP_FMT_1BIT_BE:
- if (palette_surface_format == SPICE_SURFACE_FMT_32_ARGB ||
- palette_surface_format == SPICE_SURFACE_FMT_32_xRGB) {
- bitmap_1be_32_to_32(dest, dest_stride, src, src_stride, width, end, palette);
- } else if (palette_surface_format == SPICE_SURFACE_FMT_16_555) {
- bitmap_1be_16_to_16_555(dest, dest_stride, src, src_stride, width, end, palette);
- } else {
- PANIC("Unsupported palette format");
- }
- break;
- default:
- PANIC("Unsupported bitmap format");
- break;
- }
-
- return dest_image;
-}
-
-static int pixman_format_compatible (pixman_format_code_t dest_format,
- pixman_format_code_t src_format)
-{
- if (dest_format == src_format) {
- return TRUE;
- }
-
- if (src_format == PIXMAN_a8r8g8b8 &&
- dest_format == PIXMAN_x8r8g8b8) {
- /* This is the same, we just ignore the alphas */
- return TRUE;
- }
-
- return FALSE;
-}
-
-pixman_image_t *spice_bitmap_convert_to_pixman(pixman_format_code_t dest_format,
- pixman_image_t *dest_image,
- int src_format,
- int flags,
- int width,
- int height,
- uint8_t *src,
- int src_stride,
- uint32_t palette_surface_format,
- SpicePalette *palette)
-{
- pixman_image_t *src_image;
- pixman_format_code_t native_format;
-
- if (dest_image == NULL) {
- dest_image = pixman_image_create_bits (dest_format,
- width, height,
- NULL, 0);
- }
-
- native_format =
- spice_bitmap_format_to_pixman(src_format, palette_surface_format);
-
- if (pixman_format_compatible (dest_format, native_format)) {
- return spice_bitmap_to_pixman(dest_image,
- src_format,
- flags, width,height,
- src, src_stride,
- palette_surface_format, palette);
- }
-
- src_image = spice_bitmap_try_as_pixman(src_format,
- flags, width,height,
- src, src_stride);
-
- /* Can't convert directly, need a temporary copy
- * Hopefully most bitmap reads should not need conversion (i.e.
- * hit the spice_bitmap_to_pixmap case above) or work with the
- * try_as_pixmap case, but in case some specific combination
- * shows up here commonly we might want to add non-temporary
- * conversion special casing here */
- if (src_image == NULL) {
- src_image = spice_bitmap_to_pixman(NULL,
- src_format,
- flags, width,height,
- src, src_stride,
- palette_surface_format, palette);
- }
-
- pixman_image_composite32 (PIXMAN_OP_SRC,
- src_image, NULL, dest_image,
- 0, 0,
- 0, 0,
- 0, 0,
- width, height);
-
- pixman_image_unref (src_image);
-
- return dest_image;
-}
diff --git a/common/pixman_utils.h b/common/pixman_utils.h
deleted file mode 100644
index 61eaddd..0000000
--- a/common/pixman_utils.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H__PIXMAN_UTILS
-#define _H__PIXMAN_UTILS
-
-#include <spice/types.h>
-#include <stdlib.h>
-#define PIXMAN_DONT_DEFINE_STDINT
-#include <pixman.h>
-
-#include "draw.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* This lists all possible 2 argument binary raster ops.
- * This enum has the same values as the X11 GXcopy type
- * and same as the GL constants (GL_AND etc) if you
- * or it with 0x1500. However it is not exactly the
- * same as the win32 ROP2 type (they use another order).
- */
-typedef enum {
- SPICE_ROP_CLEAR, /* 0x0 0 */
- SPICE_ROP_AND, /* 0x1 src AND dst */
- SPICE_ROP_AND_REVERSE, /* 0x2 src AND NOT dst */
- SPICE_ROP_COPY, /* 0x3 src */
- SPICE_ROP_AND_INVERTED, /* 0x4 (NOT src) AND dst */
- SPICE_ROP_NOOP, /* 0x5 dst */
- SPICE_ROP_XOR, /* 0x6 src XOR dst */
- SPICE_ROP_OR, /* 0x7 src OR dst */
- SPICE_ROP_NOR, /* 0x8 (NOT src) AND (NOT dst) */
- SPICE_ROP_EQUIV, /* 0x9 (NOT src) XOR dst */
- SPICE_ROP_INVERT, /* 0xa NOT dst */
- SPICE_ROP_OR_REVERSE, /* 0xb src OR (NOT dst) */
- SPICE_ROP_COPY_INVERTED, /* 0xc NOT src */
- SPICE_ROP_OR_INVERTED, /* 0xd (NOT src) OR dst */
- SPICE_ROP_NAND, /* 0xe (NOT src) OR (NOT dst) */
- SPICE_ROP_SET /* 0xf 1 */
-} SpiceROP;
-
-
-int spice_pixman_image_get_bpp(pixman_image_t *image);
-
-pixman_format_code_t spice_surface_format_to_pixman(uint32_t surface_format);
-pixman_format_code_t spice_bitmap_format_to_pixman(int bitmap_format,
- uint32_t palette_surface_format);
-pixman_image_t *spice_bitmap_try_as_pixman(int src_format, int flags,
- int width, int height,
- uint8_t *data, int stride);
-pixman_image_t *spice_bitmap_to_pixman(pixman_image_t *dest_image,
- int src_format, int flags,
- int width, int height,
- uint8_t *src, int src_stride,
- uint32_t palette_surface_format,
- SpicePalette *palette);
-pixman_image_t *spice_bitmap_convert_to_pixman(pixman_format_code_t dest_format,
- pixman_image_t *dest_image,
- int src_format, int flags,
- int width, int height,
- uint8_t *src, int src_stride,
- uint32_t palette_surface_format,
- SpicePalette *palette);
-
-void spice_pixman_region32_init_from_bitmap(pixman_region32_t *region,
- uint32_t *data,
- int width, int height,
- int stride);
-pixman_bool_t spice_pixman_region32_init_rects(pixman_region32_t *region,
- const SpiceRect *rects,
- int count);
-void spice_pixman_fill_rect(pixman_image_t *dest,
- int x, int y,
- int w, int h,
- uint32_t value);
-void spice_pixman_fill_rect_rop(pixman_image_t *dest,
- int x, int y,
- int w, int h,
- uint32_t value,
- SpiceROP rop);
-void spice_pixman_tile_rect(pixman_image_t *dest,
- int x, int y,
- int w, int h,
- pixman_image_t *tile,
- int offset_x,
- int offset_y);
-void spice_pixman_tile_rect_rop(pixman_image_t *dest,
- int x, int y,
- int w, int h,
- pixman_image_t *tile,
- int offset_x,
- int offset_y,
- SpiceROP rop);
-void spice_pixman_blit(pixman_image_t *dest,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int w, int h);
-void spice_pixman_blit_rop(pixman_image_t *dest,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int w, int h,
- SpiceROP rop);
-void spice_pixman_blit_colorkey(pixman_image_t *dest,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- uint32_t transparent_color);
-void spice_pixman_copy_rect(pixman_image_t *image,
- int src_x, int src_y,
- int w, int h,
- int dest_x, int dest_y);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _H__PIXMAN_UTILS */
diff --git a/common/quic.c b/common/quic.c
deleted file mode 100644
index 707724a..0000000
--- a/common/quic.c
+++ /dev/null
@@ -1,1699 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-// Red Hat image compression based on SFALIC by Roman Starosolski
-// http://sun.iinf.polsl.gliwice.pl/~rstaros/sfalic/index.html
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "quic.h"
-#include <spice/macros.h>
-#include "bitops.h"
-
-//#define DEBUG
-
-#define RLE
-#define RLE_STAT
-#define PRED_1
-//#define RLE_PRED_1
-#define RLE_PRED_2
-//#define RLE_PRED_3
-#define QUIC_RGB
-
-#define QUIC_MAGIC (*(uint32_t *)"QUIC")
-#define QUIC_VERSION_MAJOR 0U
-#define QUIC_VERSION_MINOR 1U
-#define QUIC_VERSION ((QUIC_VERSION_MAJOR << 16) | (QUIC_VERSION_MAJOR & 0xffff))
-
-#ifdef DEBUG
-
-#define ASSERT(usr, x) \
- if (!(x)) (usr)->error(usr, "%s: ASSERT %s failed\n", __FUNCTION__, #x);
-
-#else
-
-#define ASSERT(usr, x)
-
-#endif
-
-typedef uint8_t BYTE;
-
-/* maximum number of codes in family */
-#define MAXNUMCODES 8
-
-/* model evolution, warning: only 1,3 and 5 allowed */
-#define DEFevol 3
-#define MINevol 0
-#define MAXevol 5
-
-/* starting wait mask index */
-#define DEFwmistart 0
-#define MINwmistart 0
-
-/* codeword length limit */
-#define DEFmaxclen 26
-
-/* target wait mask index */
-#define DEFwmimax 6
-
-/* number of symbols to encode before increasing wait mask index */
-#define DEFwminext 2048
-#define MINwminext 1
-#define MAXwminext 100000000
-
-typedef struct QuicFamily {
- unsigned int nGRcodewords[MAXNUMCODES]; /* indexed by code number, contains number of
- unmodified GR codewords in the code */
- unsigned int notGRcwlen[MAXNUMCODES]; /* indexed by code number, contains codeword
- length of the not-GR codeword */
- unsigned int notGRprefixmask[MAXNUMCODES]; /* indexed by code number, contains mask to
- determine if the codeword is GR or not-GR */
- unsigned int notGRsuffixlen[MAXNUMCODES]; /* indexed by code number, contains suffix
- length of the not-GR codeword */
-
- /* array for translating distribution U to L for depths up to 8 bpp,
- initialized by decorelateinit() */
- BYTE xlatU2L[256];
-
- /* array for translating distribution L to U for depths up to 8 bpp,
- initialized by corelateinit() */
- unsigned int xlatL2U[256];
-} QuicFamily;
-
-static QuicFamily family_8bpc;
-static QuicFamily family_5bpc;
-
-typedef unsigned COUNTER; /* counter in the array of counters in bucket of the data model */
-
-typedef struct s_bucket {
- COUNTER *pcounters; /* pointer to array of counters */
- unsigned int bestcode; /* best code so far */
-} s_bucket;
-
-typedef struct Encoder Encoder;
-
-typedef struct CommonState {
- Encoder *encoder;
-
- unsigned int waitcnt;
- unsigned int tabrand_seed;
- unsigned int wm_trigger;
- unsigned int wmidx;
- unsigned int wmileft;
-
-#ifdef RLE_STAT
- int melcstate; /* index to the state array */
-
- int melclen; /* contents of the state array location
- indexed by melcstate: the "expected"
- run length is 2^melclen, shorter runs are
- encoded by a 1 followed by the run length
- in binary representation, wit a fixed length
- of melclen bits */
-
- unsigned long melcorder; /* 2^ melclen */
-#endif
-} CommonState;
-
-
-#define MAX_CHANNELS 4
-
-typedef struct FamilyStat {
- s_bucket **buckets_ptrs;
- s_bucket *buckets_buf;
- COUNTER *counters;
-} FamilyStat;
-
-typedef struct Channel {
- Encoder *encoder;
-
- int correlate_row_width;
- BYTE *correlate_row;
-
- s_bucket **_buckets_ptrs;
-
- FamilyStat family_stat_8bpc;
- FamilyStat family_stat_5bpc;
-
- CommonState state;
-} Channel;
-
-struct Encoder {
- QuicUsrContext *usr;
- QuicImageType type;
- unsigned int width;
- unsigned int height;
- unsigned int num_channels;
-
- unsigned int n_buckets_8bpc;
- unsigned int n_buckets_5bpc;
-
- unsigned int io_available_bits;
- uint32_t io_word;
- uint32_t io_next_word;
- uint32_t *io_now;
- uint32_t *io_end;
- uint32_t io_words_count;
-
- int rows_completed;
-
- Channel channels[MAX_CHANNELS];
-
- CommonState rgb_state;
-};
-
-/* target wait mask index */
-static int wmimax = DEFwmimax;
-
-/* number of symbols to encode before increasing wait mask index */
-static int wminext = DEFwminext;
-
-/* model evolution mode */
-static int evol = DEFevol;
-
-/* bppmask[i] contains i ones as lsb-s */
-static const unsigned long int bppmask[33] = {
- 0x00000000, /* [0] */
- 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
- 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
- 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
- 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
- 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
- 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
- 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
- 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff /* [32] */
-};
-
-static const unsigned int bitat[32] = {
- 0x00000001, 0x00000002, 0x00000004, 0x00000008,
- 0x00000010, 0x00000020, 0x00000040, 0x00000080,
- 0x00000100, 0x00000200, 0x00000400, 0x00000800,
- 0x00001000, 0x00002000, 0x00004000, 0x00008000,
- 0x00010000, 0x00020000, 0x00040000, 0x00080000,
- 0x00100000, 0x00200000, 0x00400000, 0x00800000,
- 0x01000000, 0x02000000, 0x04000000, 0x08000000,
- 0x10000000, 0x20000000, 0x40000000, 0x80000000 /* [31]*/
-};
-
-
-#define TABRAND_TABSIZE 256
-#define TABRAND_SEEDMASK 0x0ff
-
-static const unsigned int tabrand_chaos[TABRAND_TABSIZE] = {
- 0x02c57542, 0x35427717, 0x2f5a2153, 0x9244f155, 0x7bd26d07, 0x354c6052, 0x57329b28, 0x2993868e,
- 0x6cd8808c, 0x147b46e0, 0x99db66af, 0xe32b4cac, 0x1b671264, 0x9d433486, 0x62a4c192, 0x06089a4b,
- 0x9e3dce44, 0xdaabee13, 0x222425ea, 0xa46f331d, 0xcd589250, 0x8bb81d7f, 0xc8b736b9, 0x35948d33,
- 0xd7ac7fd0, 0x5fbe2803, 0x2cfbc105, 0x013dbc4e, 0x7a37820f, 0x39f88e9e, 0xedd58794, 0xc5076689,
- 0xfcada5a4, 0x64c2f46d, 0xb3ba3243, 0x8974b4f9, 0x5a05aebd, 0x20afcd00, 0x39e2b008, 0x88a18a45,
- 0x600bde29, 0xf3971ace, 0xf37b0a6b, 0x7041495b, 0x70b707ab, 0x06beffbb, 0x4206051f, 0xe13c4ee3,
- 0xc1a78327, 0x91aa067c, 0x8295f72a, 0x732917a6, 0x1d871b4d, 0x4048f136, 0xf1840e7e, 0x6a6048c1,
- 0x696cb71a, 0x7ff501c3, 0x0fc6310b, 0x57e0f83d, 0x8cc26e74, 0x11a525a2, 0x946934c7, 0x7cd888f0,
- 0x8f9d8604, 0x4f86e73b, 0x04520316, 0xdeeea20c, 0xf1def496, 0x67687288, 0xf540c5b2, 0x22401484,
- 0x3478658a, 0xc2385746, 0x01979c2c, 0x5dad73c8, 0x0321f58b, 0xf0fedbee, 0x92826ddf, 0x284bec73,
- 0x5b1a1975, 0x03df1e11, 0x20963e01, 0xa17cf12b, 0x740d776e, 0xa7a6bf3c, 0x01b5cce4, 0x1118aa76,
- 0xfc6fac0a, 0xce927e9b, 0x00bf2567, 0x806f216c, 0xbca69056, 0x795bd3e9, 0xc9dc4557, 0x8929b6c2,
- 0x789d52ec, 0x3f3fbf40, 0xb9197368, 0xa38c15b5, 0xc3b44fa8, 0xca8333b0, 0xb7e8d590, 0xbe807feb,
- 0xbf5f8360, 0xd99e2f5c, 0x372928e1, 0x7c757c4c, 0x0db5b154, 0xc01ede02, 0x1fc86e78, 0x1f3985be,
- 0xb4805c77, 0x00c880fa, 0x974c1b12, 0x35ab0214, 0xb2dc840d, 0x5b00ae37, 0xd313b026, 0xb260969d,
- 0x7f4c8879, 0x1734c4d3, 0x49068631, 0xb9f6a021, 0x6b863e6f, 0xcee5debf, 0x29f8c9fb, 0x53dd6880,
- 0x72b61223, 0x1f67a9fd, 0x0a0f6993, 0x13e59119, 0x11cca12e, 0xfe6b6766, 0x16b6effc, 0x97918fc4,
- 0xc2b8a563, 0x94f2f741, 0x0bfa8c9a, 0xd1537ae8, 0xc1da349c, 0x873c60ca, 0x95005b85, 0x9b5c080e,
- 0xbc8abbd9, 0xe1eab1d2, 0x6dac9070, 0x4ea9ebf1, 0xe0cf30d4, 0x1ef5bd7b, 0xd161043e, 0x5d2fa2e2,
- 0xff5d3cae, 0x86ed9f87, 0x2aa1daa1, 0xbd731a34, 0x9e8f4b22, 0xb1c2c67a, 0xc21758c9, 0xa182215d,
- 0xccb01948, 0x8d168df7, 0x04238cfe, 0x368c3dbc, 0x0aeadca5, 0xbad21c24, 0x0a71fee5, 0x9fc5d872,
- 0x54c152c6, 0xfc329483, 0x6783384a, 0xeddb3e1c, 0x65f90e30, 0x884ad098, 0xce81675a, 0x4b372f7d,
- 0x68bf9a39, 0x43445f1e, 0x40f8d8cb, 0x90d5acb6, 0x4cd07282, 0x349eeb06, 0x0c9d5332, 0x520b24ef,
- 0x80020447, 0x67976491, 0x2f931ca3, 0xfe9b0535, 0xfcd30220, 0x61a9e6cc, 0xa487d8d7, 0x3f7c5dd1,
- 0x7d0127c5, 0x48f51d15, 0x60dea871, 0xc9a91cb7, 0x58b53bb3, 0x9d5e0b2d, 0x624a78b4, 0x30dbee1b,
- 0x9bdf22e7, 0x1df5c299, 0x2d5643a7, 0xf4dd35ff, 0x03ca8fd6, 0x53b47ed8, 0x6f2c19aa, 0xfeb0c1f4,
- 0x49e54438, 0x2f2577e6, 0xbf876969, 0x72440ea9, 0xfa0bafb8, 0x74f5b3a0, 0x7dd357cd, 0x89ce1358,
- 0x6ef2cdda, 0x1e7767f3, 0xa6be9fdb, 0x4f5f88f8, 0xba994a3a, 0x08ca6b65, 0xe0893818, 0x9e00a16a,
- 0xf42bfc8f, 0x9972eedc, 0x749c8b51, 0x32c05f5e, 0xd706805f, 0x6bfbb7cf, 0xd9210a10, 0x31a1db97,
- 0x923a9559, 0x37a7a1f6, 0x059f8861, 0xca493e62, 0x65157e81, 0x8f6467dd, 0xab85ff9f, 0x9331aff2,
- 0x8616b9f5, 0xedbd5695, 0xee7e29b1, 0x313ac44f, 0xb903112f, 0x432ef649, 0xdc0a36c0, 0x61cf2bba,
- 0x81474925, 0xa8b6c7ad, 0xee5931de, 0xb2f8158d, 0x59fb7409, 0x2e3dfaed, 0x9af25a3f, 0xe1fed4d5,
-};
-
-static unsigned int stabrand(void)
-{
- //ASSERT( !(TABRAND_SEEDMASK & TABRAND_TABSIZE));
- //ASSERT( TABRAND_SEEDMASK + 1 == TABRAND_TABSIZE );
-
- return TABRAND_SEEDMASK;
-}
-
-static unsigned int tabrand(unsigned int *tabrand_seed)
-{
- return tabrand_chaos[++*tabrand_seed & TABRAND_SEEDMASK];
-}
-
-static const unsigned short besttrigtab[3][11] = { /* array of wm_trigger for waitmask and evol,
- used by set_wm_trigger() */
- /* 1 */ { 550, 900, 800, 700, 500, 350, 300, 200, 180, 180, 160},
- /* 3 */ { 110, 550, 900, 800, 550, 400, 350, 250, 140, 160, 140},
- /* 5 */ { 100, 120, 550, 900, 700, 500, 400, 300, 220, 250, 160}
-};
-
-/* set wm_trigger knowing waitmask (param) and evol (glob)*/
-static void set_wm_trigger(CommonState *state)
-{
- unsigned int wm = state->wmidx;
- if (wm > 10) {
- wm = 10;
- }
-
- ASSERT(state->encoder->usr, evol < 6);
-
- state->wm_trigger = besttrigtab[evol / 2][wm];
-
- ASSERT(state->encoder->usr, state->wm_trigger <= 2000);
- ASSERT(state->encoder->usr, state->wm_trigger >= 1);
-}
-
-static int ceil_log_2(int val) /* ceil(log_2(val)) */
-{
- int result;
-
- //ASSERT(val>0);
-
- if (val == 1) {
- return 0;
- }
-
- result = 1;
- val -= 1;
- while (val >>= 1) {
- result++;
- }
-
- return result;
-}
-
-/* number of leading zeroes in the byte, used by cntlzeroes(uint)*/
-static const BYTE lzeroes[256] = {
- 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-/* count leading zeroes */
-static unsigned int cnt_l_zeroes(const unsigned int bits)
-{
- if (bits & 0xff800000) {
- return lzeroes[bits >> 24];
- } else if (bits & 0xffff8000) {
- return 8 + lzeroes[(bits >> 16) & 0x000000ff];
- } else if (bits & 0xffffff80) {
- return 16 + lzeroes[(bits >> 8) & 0x000000ff];
- } else {
- return 24 + lzeroes[bits & 0x000000ff];
- }
-}
-
-#define QUIC_FAMILY_8BPC
-#include "quic_family_tmpl.c"
-
-#ifdef QUIC_RGB
-#define QUIC_FAMILY_5BPC
-#include "quic_family_tmpl.c"
-#endif
-
-static void decorelate_init(QuicFamily *family, int bpc)
-{
- const unsigned int pixelbitmask = bppmask[bpc];
- const unsigned int pixelbitmaskshr = pixelbitmask >> 1;
- unsigned int s;
-
- //ASSERT(bpc <= 8);
-
- for (s = 0; s <= pixelbitmask; s++) {
- if (s <= pixelbitmaskshr) {
- family->xlatU2L[s] = s << 1;
- } else {
- family->xlatU2L[s] = ((pixelbitmask - s) << 1) + 1;
- }
- }
-}
-
-static void corelate_init(QuicFamily *family, int bpc)
-{
- const unsigned long int pixelbitmask = bppmask[bpc];
- unsigned long int s;
-
- //ASSERT(bpc <= 8);
-
- for (s = 0; s <= pixelbitmask; s++) {
- if (s & 0x01) {
- family->xlatL2U[s] = pixelbitmask - (s >> 1);
- } else {
- family->xlatL2U[s] = (s >> 1);
- }
- }
-}
-
-static void family_init(QuicFamily *family, int bpc, int limit)
-{
- int l;
-
- for (l = 0; l < bpc; l++) { /* fill arrays indexed by code number */
- int altprefixlen, altcodewords;
-
- altprefixlen = limit - bpc;
- if (altprefixlen > (int)(bppmask[bpc - l])) {
- altprefixlen = bppmask[bpc - l];
- }
-
- altcodewords = bppmask[bpc] + 1 - (altprefixlen << l);
-
- family->nGRcodewords[l] = (altprefixlen << l);
- family->notGRcwlen[l] = altprefixlen + ceil_log_2(altcodewords);
- family->notGRprefixmask[l] = bppmask[32 - altprefixlen]; /* needed for decoding only */
- family->notGRsuffixlen[l] = ceil_log_2(altcodewords); /* needed for decoding only */
- }
-
- decorelate_init(family, bpc);
- corelate_init(family, bpc);
-}
-
-static void more_io_words(Encoder *encoder)
-{
- uint32_t *io_ptr;
- int num_io_words = encoder->usr->more_space(encoder->usr, &io_ptr, encoder->rows_completed);
- if (num_io_words <= 0) {
- encoder->usr->error(encoder->usr, "%s: no more words\n", __FUNCTION__);
- }
- ASSERT(encoder->usr, io_ptr);
- encoder->io_words_count += num_io_words;
- encoder->io_now = io_ptr;
- encoder->io_end = encoder->io_now + num_io_words;
-}
-
-static void __write_io_word(Encoder *encoder)
-{
- more_io_words(encoder);
- *(encoder->io_now++) = encoder->io_word;
-}
-
-static void (*__write_io_word_ptr)(Encoder *encoder) = __write_io_word;
-
-static INLINE void write_io_word(Encoder *encoder)
-{
- if (encoder->io_now == encoder->io_end) {
- __write_io_word_ptr(encoder); //disable inline optimizations
- return;
- }
- *(encoder->io_now++) = encoder->io_word;
-}
-
-static INLINE void encode(Encoder *encoder, unsigned int word, unsigned int len)
-{
- int delta;
-
- ASSERT(encoder->usr, len > 0 && len < 32);
- ASSERT(encoder->usr, !(word & ~bppmask[len]));
- if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
- encoder->io_available_bits = delta;
- encoder->io_word |= word << encoder->io_available_bits;
- return;
- }
- delta = -delta;
- encoder->io_word |= word >> delta;
- write_io_word(encoder);
- encoder->io_available_bits = 32 - delta;
- encoder->io_word = word << encoder->io_available_bits;
-
- ASSERT(encoder->usr, encoder->io_available_bits < 32);
- ASSERT(encoder->usr, (encoder->io_word & bppmask[encoder->io_available_bits]) == 0);
-}
-
-static INLINE void encode_32(Encoder *encoder, unsigned int word)
-{
- encode(encoder, word >> 16, 16);
- encode(encoder, word & 0x0000ffff, 16);
-}
-
-static INLINE void flush(Encoder *encoder)
-{
- if (encoder->io_available_bits > 0 && encoder->io_available_bits != 32) {
- encode(encoder, 0, encoder->io_available_bits);
- }
- encode_32(encoder, 0);
- encode(encoder, 0, 1);
-}
-
-static void __read_io_word(Encoder *encoder)
-{
- more_io_words(encoder);
- encoder->io_next_word = *(encoder->io_now++);
-}
-
-static void (*__read_io_word_ptr)(Encoder *encoder) = __read_io_word;
-
-
-static INLINE void read_io_word(Encoder *encoder)
-{
- if (encoder->io_now == encoder->io_end) {
- __read_io_word_ptr(encoder); //disable inline optimizations
- return;
- }
- ASSERT(encoder->usr, encoder->io_now < encoder->io_end);
- encoder->io_next_word = *(encoder->io_now++);
-}
-
-static INLINE void decode_eatbits(Encoder *encoder, int len)
-{
- int delta;
-
- ASSERT(encoder->usr, len > 0 && len < 32);
- encoder->io_word <<= len;
-
- if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
- encoder->io_available_bits = delta;
- encoder->io_word |= encoder->io_next_word >> encoder->io_available_bits;
- return;
- }
-
- delta = -delta;
- encoder->io_word |= encoder->io_next_word << delta;
- read_io_word(encoder);
- encoder->io_available_bits = 32 - delta;
- encoder->io_word |= (encoder->io_next_word >> encoder->io_available_bits);
-}
-
-static INLINE void decode_eat32bits(Encoder *encoder)
-{
- decode_eatbits(encoder, 16);
- decode_eatbits(encoder, 16);
-}
-
-#ifdef RLE
-
-#ifdef RLE_STAT
-
-static INLINE void encode_ones(Encoder *encoder, unsigned int n)
-{
- unsigned int count;
-
- for (count = n >> 5; count; count--) {
- encode(encoder, ~0U, 32);
- }
-
- if ((n &= 0x1f)) {
- encode(encoder, (1U << n) - 1, n);
- }
-}
-
-#define MELCSTATES 32 /* number of melcode states */
-
-static int zeroLUT[256]; /* table to find out number of leading zeros */
-
-static int J[MELCSTATES] = {
- 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7,
- 7, 8, 9, 10, 11, 12, 13, 14, 15
-};
-
-/* creates the bit counting look-up table. */
-static void init_zeroLUT(void)
-{
- int i, j, k, l;
-
- j = k = 1;
- l = 8;
- for (i = 0; i < 256; ++i) {
- zeroLUT[i] = l;
- --k;
- if (k == 0) {
- k = j;
- --l;
- j *= 2;
- }
- }
-}
-
-static void encoder_init_rle(CommonState *state)
-{
- state->melcstate = 0;
- state->melclen = J[0];
- state->melcorder = 1 << state->melclen;
-}
-
-#ifdef QUIC_RGB
-
-static void encode_run(Encoder *encoder, unsigned int runlen) //todo: try use end of line
-{
- int hits = 0;
-
- while (runlen >= encoder->rgb_state.melcorder) {
- hits++;
- runlen -= encoder->rgb_state.melcorder;
- if (encoder->rgb_state.melcstate < MELCSTATES) {
- encoder->rgb_state.melclen = J[++encoder->rgb_state.melcstate];
- encoder->rgb_state.melcorder = (1L << encoder->rgb_state.melclen);
- }
- }
-
- /* send the required number of "hit" bits (one per occurrence
- of a run of length melcorder). This number is never too big:
- after 31 such "hit" bits, each "hit" would represent a run of 32K
- pixels.
- */
- encode_ones(encoder, hits);
-
- encode(encoder, runlen, encoder->rgb_state.melclen + 1);
-
- /* adjust melcoder parameters */
- if (encoder->rgb_state.melcstate) {
- encoder->rgb_state.melclen = J[--encoder->rgb_state.melcstate];
- encoder->rgb_state.melcorder = (1L << encoder->rgb_state.melclen);
- }
-}
-
-#endif
-
-static void encode_channel_run(Encoder *encoder, Channel *channel, unsigned int runlen)
-{
- //todo: try use end of line
- int hits = 0;
-
- while (runlen >= channel->state.melcorder) {
- hits++;
- runlen -= channel->state.melcorder;
- if (channel->state.melcstate < MELCSTATES) {
- channel->state.melclen = J[++channel->state.melcstate];
- channel->state.melcorder = (1L << channel->state.melclen);
- }
- }
-
- /* send the required number of "hit" bits (one per occurrence
- of a run of length melcorder). This number is never too big:
- after 31 such "hit" bits, each "hit" would represent a run of 32K
- pixels.
- */
- encode_ones(encoder, hits);
-
- encode(encoder, runlen, channel->state.melclen + 1);
-
- /* adjust melcoder parameters */
- if (channel->state.melcstate) {
- channel->state.melclen = J[--channel->state.melcstate];
- channel->state.melcorder = (1L << channel->state.melclen);
- }
-}
-
-/* decoding routine: reads bits from the input and returns a run length. */
-/* argument is the number of pixels left to end-of-line (bound on run length) */
-
-#ifdef QUIC_RGB
-static int decode_run(Encoder *encoder)
-{
- int runlen = 0;
-
- do {
- register int temp, hits;
- temp = zeroLUT[(BYTE)(~(encoder->io_word >> 24))];/* number of leading ones in the
- input stream, up to 8 */
- for (hits = 1; hits <= temp; hits++) {
- runlen += encoder->rgb_state.melcorder;
-
- if (encoder->rgb_state.melcstate < MELCSTATES) {
- encoder->rgb_state.melclen = J[++encoder->rgb_state.melcstate];
- encoder->rgb_state.melcorder = (1U << encoder->rgb_state.melclen);
- }
- }
- if (temp != 8) {
- decode_eatbits(encoder, temp + 1); /* consume the leading
- 0 of the remainder encoding */
- break;
- }
- decode_eatbits(encoder, 8);
- } while (1);
-
- /* read the length of the remainder */
- if (encoder->rgb_state.melclen) {
- runlen += encoder->io_word >> (32 - encoder->rgb_state.melclen);
- decode_eatbits(encoder, encoder->rgb_state.melclen);
- }
-
- /* adjust melcoder parameters */
- if (encoder->rgb_state.melcstate) {
- encoder->rgb_state.melclen = J[--encoder->rgb_state.melcstate];
- encoder->rgb_state.melcorder = (1U << encoder->rgb_state.melclen);
- }
-
- return runlen;
-}
-
-#endif
-
-static int decode_channel_run(Encoder *encoder, Channel *channel)
-{
- int runlen = 0;
-
- do {
- register int temp, hits;
- temp = zeroLUT[(BYTE)(~(encoder->io_word >> 24))];/* number of leading ones in the
- input stream, up to 8 */
- for (hits = 1; hits <= temp; hits++) {
- runlen += channel->state.melcorder;
-
- if (channel->state.melcstate < MELCSTATES) {
- channel->state.melclen = J[++channel->state.melcstate];
- channel->state.melcorder = (1U << channel->state.melclen);
- }
- }
- if (temp != 8) {
- decode_eatbits(encoder, temp + 1); /* consume the leading
- 0 of the remainder encoding */
- break;
- }
- decode_eatbits(encoder, 8);
- } while (1);
-
- /* read the length of the remainder */
- if (channel->state.melclen) {
- runlen += encoder->io_word >> (32 - channel->state.melclen);
- decode_eatbits(encoder, channel->state.melclen);
- }
-
- /* adjust melcoder parameters */
- if (channel->state.melcstate) {
- channel->state.melclen = J[--channel->state.melcstate];
- channel->state.melcorder = (1U << channel->state.melclen);
- }
-
- return runlen;
-}
-
-#else
-
-static INLINE void encode_run(Encoder *encoder, unsigned int len)
-{
- int odd = len & 1U;
- int msb;
-
- len &= ~1U;
-
- while ((msb = spice_bit_find_msb(len))) {
- len &= ~(1 << (msb - 1));
- ASSERT(encoder->usr, msb < 32);
- encode(encoder, (1 << (msb)) - 1, msb);
- encode(encoder, 0, 1);
- }
-
- if (odd) {
- encode(encoder, 2, 2);
- } else {
- encode(encoder, 0, 1);
- }
-}
-
-static INLINE unsigned int decode_run(Encoder *encoder)
-{
- unsigned int len = 0;
- int count;
-
- do {
- count = 0;
- while (encoder->io_word & (1U << 31)) {
- decode_eatbits(encoder, 1);
- count++;
- ASSERT(encoder->usr, count < 32);
- }
- decode_eatbits(encoder, 1);
- len += (1U << count) >> 1;
- } while (count > 1);
-
- return len;
-}
-
-#endif
-#endif
-
-static INLINE void init_decode_io(Encoder *encoder)
-{
- encoder->io_next_word = encoder->io_word = *(encoder->io_now++);
- encoder->io_available_bits = 0;
-}
-
-#ifdef __GNUC__
-#define ATTR_PACKED __attribute__ ((__packed__))
-#else
-#define ATTR_PACKED
-#pragma pack(push)
-#pragma pack(1)
-#endif
-
-typedef struct ATTR_PACKED one_byte_pixel_t {
- BYTE a;
-} one_byte_t;
-
-typedef struct ATTR_PACKED three_bytes_pixel_t {
- BYTE a;
- BYTE b;
- BYTE c;
-} three_bytes_t;
-
-typedef struct ATTR_PACKED four_bytes_pixel_t {
- BYTE a;
- BYTE b;
- BYTE c;
- BYTE d;
-} four_bytes_t;
-
-typedef struct ATTR_PACKED rgb32_pixel_t {
- BYTE b;
- BYTE g;
- BYTE r;
- BYTE pad;
-} rgb32_pixel_t;
-
-typedef struct ATTR_PACKED rgb24_pixel_t {
- BYTE b;
- BYTE g;
- BYTE r;
-} rgb24_pixel_t;
-
-typedef uint16_t rgb16_pixel_t;
-
-#ifndef __GNUC__
-#pragma pack(pop)
-#endif
-
-#undef ATTR_PACKED
-
-#define ONE_BYTE
-#include "quic_tmpl.c"
-
-#define FOUR_BYTE
-#include "quic_tmpl.c"
-
-#ifdef QUIC_RGB
-
-#define QUIC_RGB32
-#include "quic_rgb_tmpl.c"
-
-#define QUIC_RGB24
-#include "quic_rgb_tmpl.c"
-
-#define QUIC_RGB16
-#include "quic_rgb_tmpl.c"
-
-#define QUIC_RGB16_TO_32
-#include "quic_rgb_tmpl.c"
-
-#else
-
-#define THREE_BYTE
-#include "quic_tmpl.c"
-
-#endif
-
-static void fill_model_structures(Encoder *encoder, FamilyStat *family_stat,
- unsigned int rep_first, unsigned int first_size,
- unsigned int rep_next, unsigned int mul_size,
- unsigned int levels, unsigned int ncounters,
- unsigned int nbuckets, unsigned int n_buckets_ptrs)
-{
- unsigned int
- bsize,
- bstart,
- bend = 0,
- repcntr,
- bnumber;
-
- COUNTER * free_counter = family_stat->counters;/* first free location in the array of
- counters */
-
- bnumber = 0;
-
- repcntr = rep_first + 1; /* first bucket */
- bsize = first_size;
-
- do { /* others */
- if (bnumber) {
- bstart = bend + 1;
- } else {
- bstart = 0;
- }
-
- if (!--repcntr) {
- repcntr = rep_next;
- bsize *= mul_size;
- }
-
- bend = bstart + bsize - 1;
- if (bend + bsize >= levels) {
- bend = levels - 1;
- }
-
- family_stat->buckets_buf[bnumber].pcounters = free_counter;
- free_counter += ncounters;
-
- ASSERT(encoder->usr, bstart < n_buckets_ptrs);
- {
- unsigned int i;
- ASSERT(encoder->usr, bend < n_buckets_ptrs);
- for (i = bstart; i <= bend; i++) {
- family_stat->buckets_ptrs[i] = family_stat->buckets_buf + bnumber;
- }
- }
-
- bnumber++;
- } while (bend < levels - 1);
-
- ASSERT(encoder->usr, free_counter - family_stat->counters == nbuckets * ncounters);
-}
-
-static void find_model_params(Encoder *encoder,
- const int bpc,
- unsigned int *ncounters,
- unsigned int *levels,
- unsigned int *n_buckets_ptrs,
- unsigned int *repfirst,
- unsigned int *firstsize,
- unsigned int *repnext,
- unsigned int *mulsize,
- unsigned int *nbuckets)
-{
- unsigned int bsize; /* bucket size */
- unsigned int bstart, bend = 0; /* bucket start and end, range : 0 to levels-1*/
- unsigned int repcntr; /* helper */
-
- ASSERT(encoder->usr, bpc <= 8 && bpc > 0);
-
-
- *ncounters = 8;
-
- *levels = 0x1 << bpc;
-
- *n_buckets_ptrs = 0; /* ==0 means: not set yet */
-
- switch (evol) { /* set repfirst firstsize repnext mulsize */
- case 1: /* buckets contain following numbers of contexts: 1 1 1 2 2 4 4 8 8 ... */
- *repfirst = 3;
- *firstsize = 1;
- *repnext = 2;
- *mulsize = 2;
- break;
- case 3: /* 1 2 4 8 16 32 64 ... */
- *repfirst = 1;
- *firstsize = 1;
- *repnext = 1;
- *mulsize = 2;
- break;
- case 5: /* 1 4 16 64 256 1024 4096 16384 65536 */
- *repfirst = 1;
- *firstsize = 1;
- *repnext = 1;
- *mulsize = 4;
- break;
- case 0: /* obsolete */
- case 2: /* obsolete */
- case 4: /* obsolete */
- encoder->usr->error(encoder->usr, "findmodelparams(): evol value obsolete!!!\n");
- default:
- encoder->usr->error(encoder->usr, "findmodelparams(): evol out of range!!!\n");
- }
-
- *nbuckets = 0;
- repcntr = *repfirst + 1; /* first bucket */
- bsize = *firstsize;
-
- do { /* other buckets */
- if (nbuckets) { /* bucket start */
- bstart = bend + 1;
- } else {
- bstart = 0;
- }
-
- if (!--repcntr) { /* bucket size */
- repcntr = *repnext;
- bsize *= *mulsize;
- }
-
- bend = bstart + bsize - 1; /* bucket end */
- if (bend + bsize >= *levels) { /* if following bucked was bigger than current one */
- bend = *levels - 1; /* concatenate them */
- }
-
- if (!*n_buckets_ptrs) { /* array size not set yet? */
- *n_buckets_ptrs = *levels;
- #if 0
- if (bend == *levels - 1) { /* this bucket is last - all in the first array */
- *n_buckets_ptrs = *levels;
- } else if (bsize >= 256) { /* this bucket is allowed to reside in the 2nd table */
- b_lo_ptrs = bstart;
- assert(bstart); /* previous bucket exists */
- }
- #endif
- }
-
- (*nbuckets)++;
- } while (bend < *levels - 1);
-}
-
-static int init_model_structures(Encoder *encoder, FamilyStat *family_stat,
- unsigned int rep_first, unsigned int first_size,
- unsigned int rep_next, unsigned int mul_size,
- unsigned int levels, unsigned int ncounters,
- unsigned int n_buckets_ptrs, unsigned int n_buckets)
-{
- family_stat->buckets_ptrs = (s_bucket **)encoder->usr->malloc(encoder->usr,
- n_buckets_ptrs *
- sizeof(s_bucket *));
- if (!family_stat->buckets_ptrs) {
- return FALSE;
- }
-
- family_stat->counters = (COUNTER *)encoder->usr->malloc(encoder->usr,
- n_buckets * sizeof(COUNTER) *
- MAXNUMCODES);
- if (!family_stat->counters) {
- goto error_1;
- }
-
- family_stat->buckets_buf = (s_bucket *)encoder->usr->malloc(encoder->usr,
- n_buckets * sizeof(s_bucket));
- if (!family_stat->buckets_buf) {
- goto error_2;
- }
-
- fill_model_structures(encoder, family_stat, rep_first, first_size, rep_next, mul_size, levels,
- ncounters, n_buckets, n_buckets_ptrs);
-
- return TRUE;
-
-error_2:
- encoder->usr->free(encoder->usr, family_stat->counters);
-
-error_1:
- encoder->usr->free(encoder->usr, family_stat->buckets_ptrs);
-
- return FALSE;
-}
-
-static void free_family_stat(QuicUsrContext *usr, FamilyStat *family_stat)
-{
- usr->free(usr, family_stat->buckets_ptrs);
- usr->free(usr, family_stat->counters);
- usr->free(usr, family_stat->buckets_buf);
-}
-
-static int init_channel(Encoder *encoder, Channel *channel)
-{
- unsigned int ncounters;
- unsigned int levels;
- unsigned int rep_first;
- unsigned int first_size;
- unsigned int rep_next;
- unsigned int mul_size;
- unsigned int n_buckets;
- unsigned int n_buckets_ptrs;
-
- channel->encoder = encoder;
- channel->state.encoder = encoder;
- channel->correlate_row_width = 0;
- channel->correlate_row = NULL;
-
- find_model_params(encoder, 8, &ncounters, &levels, &n_buckets_ptrs, &rep_first,
- &first_size, &rep_next, &mul_size, &n_buckets);
- encoder->n_buckets_8bpc = n_buckets;
- if (!init_model_structures(encoder, &channel->family_stat_8bpc, rep_first, first_size,
- rep_next, mul_size, levels, ncounters, n_buckets_ptrs,
- n_buckets)) {
- return FALSE;
- }
-
- find_model_params(encoder, 5, &ncounters, &levels, &n_buckets_ptrs, &rep_first,
- &first_size, &rep_next, &mul_size, &n_buckets);
- encoder->n_buckets_5bpc = n_buckets;
- if (!init_model_structures(encoder, &channel->family_stat_5bpc, rep_first, first_size,
- rep_next, mul_size, levels, ncounters, n_buckets_ptrs,
- n_buckets)) {
- free_family_stat(encoder->usr, &channel->family_stat_8bpc);
- return FALSE;
- }
-
- return TRUE;
-}
-
-static void destroy_channel(Channel *channel)
-{
- QuicUsrContext *usr = channel->encoder->usr;
- if (channel->correlate_row) {
- usr->free(usr, channel->correlate_row - 1);
- }
- free_family_stat(usr, &channel->family_stat_8bpc);
- free_family_stat(usr, &channel->family_stat_5bpc);
-}
-
-static int init_encoder(Encoder *encoder, QuicUsrContext *usr)
-{
- int i;
-
- encoder->usr = usr;
- encoder->rgb_state.encoder = encoder;
-
- for (i = 0; i < MAX_CHANNELS; i++) {
- if (!init_channel(encoder, &encoder->channels[i])) {
- for (--i; i >= 0; i--) {
- destroy_channel(&encoder->channels[i]);
- }
- return FALSE;
- }
- }
- return TRUE;
-}
-
-static int encoder_reste(Encoder *encoder, uint32_t *io_ptr, uint32_t *io_ptr_end)
-{
- ASSERT(encoder->usr, ((unsigned long)io_ptr % 4) == ((unsigned long)io_ptr_end % 4));
- ASSERT(encoder->usr, io_ptr <= io_ptr_end);
-
- encoder->rgb_state.waitcnt = 0;
- encoder->rgb_state.tabrand_seed = stabrand();
- encoder->rgb_state.wmidx = DEFwmistart;
- encoder->rgb_state.wmileft = wminext;
- set_wm_trigger(&encoder->rgb_state);
-
-#if defined(RLE) && defined(RLE_STAT)
- encoder_init_rle(&encoder->rgb_state);
-#endif
-
- encoder->io_words_count = io_ptr_end - io_ptr;
- encoder->io_now = io_ptr;
- encoder->io_end = io_ptr_end;
- encoder->rows_completed = 0;
-
- return TRUE;
-}
-
-static int encoder_reste_channels(Encoder *encoder, int channels, int width, int bpc)
-{
- int i;
-
- encoder->num_channels = channels;
-
- for (i = 0; i < channels; i++) {
- s_bucket *bucket;
- s_bucket *end_bucket;
-
- if (encoder->channels[i].correlate_row_width < width) {
- encoder->channels[i].correlate_row_width = 0;
- if (encoder->channels[i].correlate_row) {
- encoder->usr->free(encoder->usr, encoder->channels[i].correlate_row - 1);
- }
- if (!(encoder->channels[i].correlate_row = (BYTE *)encoder->usr->malloc(encoder->usr,
- width + 1))) {
- return FALSE;
- }
- encoder->channels[i].correlate_row++;
- encoder->channels[i].correlate_row_width = width;
- }
-
- if (bpc == 8) {
- MEMCLEAR(encoder->channels[i].family_stat_8bpc.counters,
- encoder->n_buckets_8bpc * sizeof(COUNTER) * MAXNUMCODES);
- bucket = encoder->channels[i].family_stat_8bpc.buckets_buf;
- end_bucket = bucket + encoder->n_buckets_8bpc;
- for (; bucket < end_bucket; bucket++) {
- bucket->bestcode = /*BPC*/ 8 - 1;
- }
- encoder->channels[i]._buckets_ptrs = encoder->channels[i].family_stat_8bpc.buckets_ptrs;
- } else if (bpc == 5) {
- MEMCLEAR(encoder->channels[i].family_stat_5bpc.counters,
- encoder->n_buckets_5bpc * sizeof(COUNTER) * MAXNUMCODES);
- bucket = encoder->channels[i].family_stat_5bpc.buckets_buf;
- end_bucket = bucket + encoder->n_buckets_5bpc;
- for (; bucket < end_bucket; bucket++) {
- bucket->bestcode = /*BPC*/ 5 - 1;
- }
- encoder->channels[i]._buckets_ptrs = encoder->channels[i].family_stat_5bpc.buckets_ptrs;
- } else {
- encoder->usr->warn(encoder->usr, "%s: bad bpc %d\n", __FUNCTION__, bpc);
- return FALSE;
- }
-
- encoder->channels[i].state.waitcnt = 0;
- encoder->channels[i].state.tabrand_seed = stabrand();
- encoder->channels[i].state.wmidx = DEFwmistart;
- encoder->channels[i].state.wmileft = wminext;
- set_wm_trigger(&encoder->channels[i].state);
-
-#if defined(RLE) && defined(RLE_STAT)
- encoder_init_rle(&encoder->channels[i].state);
-#endif
- }
- return TRUE;
-}
-
-static void quic_image_params(Encoder *encoder, QuicImageType type, int *channels, int *bpc)
-{
- ASSERT(encoder->usr, channels && bpc);
- switch (type) {
- case QUIC_IMAGE_TYPE_GRAY:
- *channels = 1;
- *bpc = 8;
- break;
- case QUIC_IMAGE_TYPE_RGB16:
- *channels = 3;
- *bpc = 5;
-#ifndef QUIC_RGB
- encoder->usr->error(encoder->usr, "not implemented\n");
-#endif
- break;
- case QUIC_IMAGE_TYPE_RGB24:
- *channels = 3;
- *bpc = 8;
- break;
- case QUIC_IMAGE_TYPE_RGB32:
- *channels = 3;
- *bpc = 8;
- break;
- case QUIC_IMAGE_TYPE_RGBA:
- *channels = 4;
- *bpc = 8;
- break;
- case QUIC_IMAGE_TYPE_INVALID:
- default:
- *channels = 0;
- *bpc = 0;
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
-}
-
-#define FILL_LINES() { \
- if (line == lines_end) { \
- int n = encoder->usr->more_lines(encoder->usr, &line); \
- if (n <= 0) { \
- encoder->usr->error(encoder->usr, "more lines failed\n"); \
- } \
- lines_end = line + n * stride; \
- } \
-}
-
-#define NEXT_LINE() { \
- line += stride; \
- FILL_LINES(); \
-}
-
-#define QUIC_COMPRESS_RGB(bits) \
- encoder->channels[0].correlate_row[-1] = 0; \
- encoder->channels[1].correlate_row[-1] = 0; \
- encoder->channels[2].correlate_row[-1] = 0; \
- quic_rgb##bits##_compress_row0(encoder, (rgb##bits##_pixel_t *)(line), width); \
- encoder->rows_completed++; \
- for (row = 1; row < height; row++) { \
- prev = line; \
- NEXT_LINE(); \
- encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0]; \
- encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0]; \
- encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0]; \
- quic_rgb##bits##_compress_row(encoder, (rgb##bits##_pixel_t *)prev, \
- (rgb##bits##_pixel_t *)line, width); \
- encoder->rows_completed++; \
- }
-
-int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
- uint8_t *line, unsigned int num_lines, int stride,
- uint32_t *io_ptr, unsigned int num_io_words)
-{
- Encoder *encoder = (Encoder *)quic;
- uint32_t *io_ptr_end = io_ptr + num_io_words;
- uint8_t *lines_end;
- int row;
- uint8_t *prev;
- int channels;
- int bpc;
-#ifndef QUIC_RGB
- int i;
-#endif
-
- ASSERT(encoder->usr, line);
- lines_end = line + num_lines * stride;
-
- quic_image_params(encoder, type, &channels, &bpc);
-
- if (!encoder_reste(encoder, io_ptr, io_ptr_end) ||
- !encoder_reste_channels(encoder, channels, width, bpc)) {
- return QUIC_ERROR;
- }
-
- encoder->io_word = 0;
- encoder->io_available_bits = 32;
-
- encode_32(encoder, QUIC_MAGIC);
- encode_32(encoder, QUIC_VERSION);
- encode_32(encoder, type);
- encode_32(encoder, width);
- encode_32(encoder, height);
-
- FILL_LINES();
-
- switch (type) {
-#ifdef QUIC_RGB
- case QUIC_IMAGE_TYPE_RGB32:
- ASSERT(encoder->usr, ABS(stride) >= width * 4);
- QUIC_COMPRESS_RGB(32);
- break;
- case QUIC_IMAGE_TYPE_RGB24:
- ASSERT(encoder->usr, ABS(stride) >= width * 3);
- QUIC_COMPRESS_RGB(24);
- break;
- case QUIC_IMAGE_TYPE_RGB16:
- ASSERT(encoder->usr, ABS(stride) >= width * 2);
- QUIC_COMPRESS_RGB(16);
- break;
- case QUIC_IMAGE_TYPE_RGBA:
- ASSERT(encoder->usr, ABS(stride) >= width * 4);
-
- encoder->channels[0].correlate_row[-1] = 0;
- encoder->channels[1].correlate_row[-1] = 0;
- encoder->channels[2].correlate_row[-1] = 0;
- quic_rgb32_compress_row0(encoder, (rgb32_pixel_t *)(line), width);
-
- encoder->channels[3].correlate_row[-1] = 0;
- quic_four_compress_row0(encoder, &encoder->channels[3], (four_bytes_t *)(line + 3), width);
-
- encoder->rows_completed++;
-
- for (row = 1; row < height; row++) {
- prev = line;
- NEXT_LINE();
- encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
- encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0];
- encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0];
- quic_rgb32_compress_row(encoder, (rgb32_pixel_t *)prev, (rgb32_pixel_t *)line, width);
-
- encoder->channels[3].correlate_row[-1] = encoder->channels[3].correlate_row[0];
- quic_four_compress_row(encoder, &encoder->channels[3], (four_bytes_t *)(prev + 3),
- (four_bytes_t *)(line + 3), width);
- encoder->rows_completed++;
- }
- break;
-#else
- case QUIC_IMAGE_TYPE_RGB24:
- ASSERT(encoder->usr, ABS(stride) >= width * 3);
- for (i = 0; i < 3; i++) {
- encoder->channels[i].correlate_row[-1] = 0;
- quic_three_compress_row0(encoder, &encoder->channels[i], (three_bytes_t *)(line + i),
- width);
- }
- encoder->rows_completed++;
- for (row = 1; row < height; row++) {
- prev = line;
- NEXT_LINE();
- for (i = 0; i < 3; i++) {
- encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
- quic_three_compress_row(encoder, &encoder->channels[i], (three_bytes_t *)(prev + i),
- (three_bytes_t *)(line + i), width);
- }
- encoder->rows_completed++;
- }
- break;
- case QUIC_IMAGE_TYPE_RGB32:
- case QUIC_IMAGE_TYPE_RGBA:
- ASSERT(encoder->usr, ABS(stride) >= width * 4);
- for (i = 0; i < channels; i++) {
- encoder->channels[i].correlate_row[-1] = 0;
- quic_four_compress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(line + i),
- width);
- }
- encoder->rows_completed++;
- for (row = 1; row < height; row++) {
- prev = line;
- NEXT_LINE();
- for (i = 0; i < channels; i++) {
- encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
- quic_four_compress_row(encoder, &encoder->channels[i], (four_bytes_t *)(prev + i),
- (four_bytes_t *)(line + i), width);
- }
- encoder->rows_completed++;
- }
- break;
-#endif
- case QUIC_IMAGE_TYPE_GRAY:
- ASSERT(encoder->usr, ABS(stride) >= width);
- encoder->channels[0].correlate_row[-1] = 0;
- quic_one_compress_row0(encoder, &encoder->channels[0], (one_byte_t *)line, width);
- encoder->rows_completed++;
- for (row = 1; row < height; row++) {
- prev = line;
- NEXT_LINE();
- encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
- quic_one_compress_row(encoder, &encoder->channels[0], (one_byte_t *)prev,
- (one_byte_t *)line, width);
- encoder->rows_completed++;
- }
- break;
- case QUIC_IMAGE_TYPE_INVALID:
- default:
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
-
- flush(encoder);
- encoder->io_words_count -= (encoder->io_end - encoder->io_now);
-
- return encoder->io_words_count;
-}
-
-int quic_decode_begin(QuicContext *quic, uint32_t *io_ptr, unsigned int num_io_words,
- QuicImageType *out_type, int *out_width, int *out_height)
-{
- Encoder *encoder = (Encoder *)quic;
- uint32_t *io_ptr_end = io_ptr + num_io_words;
- QuicImageType type;
- int width;
- int height;
- uint32_t magic;
- uint32_t version;
- int channels;
- int bpc;
-
- if (!encoder_reste(encoder, io_ptr, io_ptr_end)) {
- return QUIC_ERROR;
- }
-
- init_decode_io(encoder);
-
- magic = encoder->io_word;
- decode_eat32bits(encoder);
- if (magic != QUIC_MAGIC) {
- encoder->usr->warn(encoder->usr, "bad magic\n");
- return QUIC_ERROR;
- }
-
- version = encoder->io_word;
- decode_eat32bits(encoder);
- if (version != QUIC_VERSION) {
- encoder->usr->warn(encoder->usr, "bad version\n");
- return QUIC_ERROR;
- }
-
- type = (QuicImageType)encoder->io_word;
- decode_eat32bits(encoder);
-
- width = encoder->io_word;
- decode_eat32bits(encoder);
-
- height = encoder->io_word;
- decode_eat32bits(encoder);
-
- quic_image_params(encoder, type, &channels, &bpc);
-
- if (!encoder_reste_channels(encoder, channels, width, bpc)) {
- return QUIC_ERROR;
- }
-
- *out_width = encoder->width = width;
- *out_height = encoder->height = height;
- *out_type = encoder->type = type;
- return QUIC_OK;
-}
-
-#ifndef QUIC_RGB
-static void clear_row(four_bytes_t *row, int width)
-{
- four_bytes_t *end;
- for (end = row + width; row < end; row++) {
- row->a = 0;
- }
-}
-
-#endif
-
-#ifdef QUIC_RGB
-
-static void uncompress_rgba(Encoder *encoder, uint8_t *buf, int stride)
-{
- unsigned int row;
- uint8_t *prev;
-
- encoder->channels[0].correlate_row[-1] = 0;
- encoder->channels[1].correlate_row[-1] = 0;
- encoder->channels[2].correlate_row[-1] = 0;
- quic_rgb32_uncompress_row0(encoder, (rgb32_pixel_t *)buf, encoder->width);
-
- encoder->channels[3].correlate_row[-1] = 0;
- quic_four_uncompress_row0(encoder, &encoder->channels[3], (four_bytes_t *)(buf + 3),
- encoder->width);
-
- encoder->rows_completed++;
- for (row = 1; row < encoder->height; row++) {
- prev = buf;
- buf += stride;
-
- encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
- encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0];
- encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0];
- quic_rgb32_uncompress_row(encoder, (rgb32_pixel_t *)prev, (rgb32_pixel_t *)buf,
- encoder->width);
-
- encoder->channels[3].correlate_row[-1] = encoder->channels[3].correlate_row[0];
- quic_four_uncompress_row(encoder, &encoder->channels[3], (four_bytes_t *)(prev + 3),
- (four_bytes_t *)(buf + 3), encoder->width);
-
- encoder->rows_completed++;
- }
-}
-
-#endif
-
-static void uncompress_gray(Encoder *encoder, uint8_t *buf, int stride)
-{
- unsigned int row;
- uint8_t *prev;
-
- encoder->channels[0].correlate_row[-1] = 0;
- quic_one_uncompress_row0(encoder, &encoder->channels[0], (one_byte_t *)buf, encoder->width);
- encoder->rows_completed++;
- for (row = 1; row < encoder->height; row++) {
- prev = buf;
- buf += stride;
- encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
- quic_one_uncompress_row(encoder, &encoder->channels[0], (one_byte_t *)prev,
- (one_byte_t *)buf, encoder->width);
- encoder->rows_completed++;
- }
-}
-
-#define QUIC_UNCOMPRESS_RGB(prefix, type) \
- encoder->channels[0].correlate_row[-1] = 0; \
- encoder->channels[1].correlate_row[-1] = 0; \
- encoder->channels[2].correlate_row[-1] = 0; \
- quic_rgb##prefix##_uncompress_row0(encoder, (type *)buf, encoder->width); \
- encoder->rows_completed++; \
- for (row = 1; row < encoder->height; row++) { \
- prev = buf; \
- buf += stride; \
- encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0]; \
- encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0]; \
- encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0]; \
- quic_rgb##prefix##_uncompress_row(encoder, (type *)prev, (type *)buf, \
- encoder->width); \
- encoder->rows_completed++; \
- }
-
-int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
-{
- Encoder *encoder = (Encoder *)quic;
- unsigned int row;
- uint8_t *prev;
-#ifndef QUIC_RGB
- int i;
-#endif
-
- ASSERT(encoder->usr, buf);
-
- switch (encoder->type) {
-#ifdef QUIC_RGB
- case QUIC_IMAGE_TYPE_RGB32:
- case QUIC_IMAGE_TYPE_RGB24:
- if (type == QUIC_IMAGE_TYPE_RGB32) {
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
- QUIC_UNCOMPRESS_RGB(32, rgb32_pixel_t);
- break;
- } else if (type == QUIC_IMAGE_TYPE_RGB24) {
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 3);
- QUIC_UNCOMPRESS_RGB(24, rgb24_pixel_t);
- break;
- }
- encoder->usr->warn(encoder->usr, "unsupported output format\n");
- return QUIC_ERROR;
- case QUIC_IMAGE_TYPE_RGB16:
- if (type == QUIC_IMAGE_TYPE_RGB16) {
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 2);
- QUIC_UNCOMPRESS_RGB(16, rgb16_pixel_t);
- } else if (type == QUIC_IMAGE_TYPE_RGB32) {
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
- QUIC_UNCOMPRESS_RGB(16_to_32, rgb32_pixel_t);
- } else {
- encoder->usr->warn(encoder->usr, "unsupported output format\n");
- return QUIC_ERROR;
- }
-
- break;
- case QUIC_IMAGE_TYPE_RGBA:
-
- if (type != QUIC_IMAGE_TYPE_RGBA) {
- encoder->usr->warn(encoder->usr, "unsupported output format\n");
- return QUIC_ERROR;
- }
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
- uncompress_rgba(encoder, buf, stride);
- break;
-#else
- case QUIC_IMAGE_TYPE_RGB24:
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 3);
- for (i = 0; i < 3; i++) {
- encoder->channels[i].correlate_row[-1] = 0;
- quic_three_uncompress_row0(encoder, &encoder->channels[i], (three_bytes_t *)(buf + i),
- encoder->width);
- }
- encoder->rows_completed++;
- for (row = 1; row < encoder->height; row++) {
- prev = buf;
- buf += stride;
- for (i = 0; i < 3; i++) {
- encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
- quic_three_uncompress_row(encoder, &encoder->channels[i],
- (three_bytes_t *)(prev + i),
- (three_bytes_t *)(buf + i),
- encoder->width);
- }
- encoder->rows_completed++;
- }
- break;
- case QUIC_IMAGE_TYPE_RGB32:
- ASSERT(encoder->usr, ABS(stride) >= encoder->width * 4);
- for (i = 0; i < 3; i++) {
- encoder->channels[i].correlate_row[-1] = 0;
- quic_four_uncompress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(buf + i),
- encoder->width);
- }
- clear_row((four_bytes_t *)(buf + 3), encoder->width);
- encoder->rows_completed++;
- for (row = 1; row < encoder->height; row++) {
- prev = buf;
- buf += stride;
- for (i = 0; i < 3; i++) {
- encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
- quic_four_uncompress_row(encoder, &encoder->channels[i],
- (four_bytes_t *)(prev + i),
- (four_bytes_t *)(buf + i),
- encoder->width);
- }
- clear_row((four_bytes_t *)(buf + 3), encoder->width);
- encoder->rows_completed++;
- }
- break;
- case QUIC_IMAGE_TYPE_RGBA:
- ASSERT(encoder->usr, ABS(stride) >= encoder->width * 4);
- for (i = 0; i < 4; i++) {
- encoder->channels[i].correlate_row[-1] = 0;
- quic_four_uncompress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(buf + i),
- encoder->width);
- }
- encoder->rows_completed++;
- for (row = 1; row < encoder->height; row++) {
- prev = buf;
- buf += stride;
- for (i = 0; i < 4; i++) {
- encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
- quic_four_uncompress_row(encoder, &encoder->channels[i],
- (four_bytes_t *)(prev + i),
- (four_bytes_t *)(buf + i),
- encoder->width);
- }
- encoder->rows_completed++;
- }
- break;
-#endif
- case QUIC_IMAGE_TYPE_GRAY:
-
- if (type != QUIC_IMAGE_TYPE_GRAY) {
- encoder->usr->warn(encoder->usr, "unsupported output format\n");
- return QUIC_ERROR;
- }
- ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width);
- uncompress_gray(encoder, buf, stride);
- break;
- case QUIC_IMAGE_TYPE_INVALID:
- default:
- encoder->usr->error(encoder->usr, "bad image type\n");
- }
- return QUIC_OK;
-}
-
-static int need_init = TRUE;
-
-QuicContext *quic_create(QuicUsrContext *usr)
-{
- Encoder *encoder;
-
- if (!usr || need_init || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
- !usr->free || !usr->more_space || !usr->more_lines) {
- return NULL;
- }
-
- if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
- return NULL;
- }
-
- if (!init_encoder(encoder, usr)) {
- usr->free(usr, encoder);
- return NULL;
- }
- return (QuicContext *)encoder;
-}
-
-void quic_destroy(QuicContext *quic)
-{
- Encoder *encoder = (Encoder *)quic;
- int i;
-
- if (!quic) {
- return;
- }
-
- for (i = 0; i < MAX_CHANNELS; i++) {
- destroy_channel(&encoder->channels[i]);
- }
- encoder->usr->free(encoder->usr, encoder);
-}
-
-void quic_init(void)
-{
- if (!need_init) {
- return;
- }
- need_init = FALSE;
-
- family_init(&family_8bpc, 8, DEFmaxclen);
- family_init(&family_5bpc, 5, DEFmaxclen);
-#if defined(RLE) && defined(RLE_STAT)
- init_zeroLUT();
-#endif
-}
diff --git a/common/quic.h b/common/quic.h
deleted file mode 100644
index 7ec94f5..0000000
--- a/common/quic.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __QUIC_H
-#define __QUIC_H
-
-#include "quic_config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
- QUIC_IMAGE_TYPE_INVALID,
- QUIC_IMAGE_TYPE_GRAY,
- QUIC_IMAGE_TYPE_RGB16,
- QUIC_IMAGE_TYPE_RGB24,
- QUIC_IMAGE_TYPE_RGB32,
- QUIC_IMAGE_TYPE_RGBA
-} QuicImageType;
-
-#define QUIC_ERROR -1
-#define QUIC_OK 0
-
-typedef void *QuicContext;
-
-typedef struct QuicUsrContext QuicUsrContext;
-struct QuicUsrContext {
- void (*error)(QuicUsrContext *usr, const char *fmt, ...);
- void (*warn)(QuicUsrContext *usr, const char *fmt, ...);
- void (*info)(QuicUsrContext *usr, const char *fmt, ...);
- void *(*malloc)(QuicUsrContext *usr, int size);
- void (*free)(QuicUsrContext *usr, void *ptr);
- int (*more_space)(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed);
- int (*more_lines)(QuicUsrContext *usr, uint8_t **lines); // on return the last line of previous
- // lines bunch must still be valid
-};
-
-int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
- uint8_t *lines, unsigned int num_lines, int stride,
- uint32_t *io_ptr, unsigned int num_io_words);
-
-int quic_decode_begin(QuicContext *quic, uint32_t *io_ptr, unsigned int num_io_words,
- QuicImageType *type, int *width, int *height);
-int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride);
-
-
-QuicContext *quic_create(QuicUsrContext *usr);
-void quic_destroy(QuicContext *quic);
-
-void quic_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/quic_config.h b/common/quic_config.h
deleted file mode 100644
index 13c71f1..0000000
--- a/common/quic_config.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __QUIC_CONFIG_H
-#define __QUIC_CONFIG_H
-
-#include <spice/types.h>
-#include <spice/macros.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __GNUC__
-#include <string.h>
-#define MEMCLEAR(ptr, size) memset(ptr, 0, size)
-#else
-#ifdef QXLDD
-#include <windef.h>
-#include "os_dep.h"
-#define MEMCLEAR(ptr, size) RtlZeroMemory(ptr, size)
-#else
-#include <stddef.h>
-#include <string.h>
-#define MEMCLEAR(ptr, size) memset(ptr, 0, size)
-#endif // QXLDD
-#endif //__GNUC__
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/quic_family_tmpl.c b/common/quic_family_tmpl.c
deleted file mode 100644
index bfba0cc..0000000
--- a/common/quic_family_tmpl.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef QUIC_FAMILY_8BPC
-#undef QUIC_FAMILY_8BPC
-#define FNAME(name) name##_8bpc
-#define VNAME(name) name##_8bpc
-#define BPC 8
-#endif
-
-
-#ifdef QUIC_FAMILY_5BPC
-#undef QUIC_FAMILY_5BPC
-#define FNAME(name) name##_5bpc
-#define VNAME(name) name##_5bpc
-#define BPC 5
-#endif
-
-
-static unsigned int FNAME(golomb_code_len)(const BYTE n, const unsigned int l)
-{
- if (n < VNAME(family).nGRcodewords[l]) {
- return (n >> l) + 1 + l;
- } else {
- return VNAME(family).notGRcwlen[l];
- }
-}
-
-static void FNAME(golomb_coding)(const BYTE n, const unsigned int l, unsigned int * const codeword,
- unsigned int * const codewordlen)
-{
- if (n < VNAME(family).nGRcodewords[l]) {
- (*codeword) = bitat[l] | (n & bppmask[l]);
- (*codewordlen) = (n >> l) + l + 1;
- } else {
- (*codeword) = n - VNAME(family).nGRcodewords[l];
- (*codewordlen) = VNAME(family).notGRcwlen[l];
- }
-}
-
-static unsigned int FNAME(golomb_decoding)(const unsigned int l, const unsigned int bits,
- unsigned int * const codewordlen)
-{
- if (bits > VNAME(family).notGRprefixmask[l]) { /*GR*/
- const unsigned int zeroprefix = cnt_l_zeroes(bits); /* leading zeroes in codeword */
- const unsigned int cwlen = zeroprefix + 1 + l; /* codeword length */
- (*codewordlen) = cwlen;
- return (zeroprefix << l) | ((bits >> (32 - cwlen)) & bppmask[l]);
- } else { /* not-GR */
- const unsigned int cwlen = VNAME(family).notGRcwlen[l];
- (*codewordlen) = cwlen;
- return VNAME(family).nGRcodewords[l] + ((bits) >> (32 - cwlen) &
- bppmask[VNAME(family).notGRsuffixlen[l]]);
- }
-}
-
-/* update the bucket using just encoded curval */
-static void FNAME(update_model)(CommonState *state, s_bucket * const bucket,
- const BYTE curval, unsigned int bpp)
-{
- COUNTER * const pcounters = bucket->pcounters;
- unsigned int i;
- unsigned int bestcode;
- unsigned int bestcodelen;
- //unsigned int bpp = encoder->bpp;
-
- /* update counters, find minimum */
-
- bestcode = bpp - 1;
- bestcodelen = (pcounters[bestcode] += FNAME(golomb_code_len)(curval, bestcode));
-
- for (i = bpp - 2; i < bpp; i--) { /* NOTE: expression i<bpp for signed int i would be: i>=0 */
- const unsigned int ithcodelen = (pcounters[i] += FNAME(golomb_code_len)(curval, i));
-
- if (ithcodelen < bestcodelen) {
- bestcode = i;
- bestcodelen = ithcodelen;
- }
- }
-
- bucket->bestcode = bestcode; /* store the found minimum */
-
- if (bestcodelen > state->wm_trigger) { /* halving counters? */
- for (i = 0; i < bpp; i++) {
- pcounters[i] >>= 1;
- }
- }
-}
-
-static s_bucket *FNAME(find_bucket)(Channel *channel, const unsigned int val)
-{
- ASSERT(channel->encoder->usr, val < (0x1U << BPC));
-
- return channel->_buckets_ptrs[val];
-}
-
-#undef FNAME
-#undef VNAME
-#undef BPC
diff --git a/common/quic_rgb_tmpl.c b/common/quic_rgb_tmpl.c
deleted file mode 100644
index 8f35679..0000000
--- a/common/quic_rgb_tmpl.c
+++ /dev/null
@@ -1,765 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef QUIC_RGB32
-#undef QUIC_RGB32
-#define PIXEL rgb32_pixel_t
-#define FNAME(name) quic_rgb32_##name
-#define golomb_coding golomb_coding_8bpc
-#define golomb_decoding golomb_decoding_8bpc
-#define update_model update_model_8bpc
-#define find_bucket find_bucket_8bpc
-#define family family_8bpc
-#define BPC 8
-#define BPC_MASK 0xffU
-#define COMPRESS_IMP
-#define SET_r(pix, val) ((pix)->r = val)
-#define GET_r(pix) ((pix)->r)
-#define SET_g(pix, val) ((pix)->g = val)
-#define GET_g(pix) ((pix)->g)
-#define SET_b(pix, val) ((pix)->b = val)
-#define GET_b(pix) ((pix)->b)
-#define UNCOMPRESS_PIX_START(pix) ((pix)->pad = 0)
-#endif
-
-#ifdef QUIC_RGB24
-#undef QUIC_RGB24
-#define PIXEL rgb24_pixel_t
-#define FNAME(name) quic_rgb24_##name
-#define golomb_coding golomb_coding_8bpc
-#define golomb_decoding golomb_decoding_8bpc
-#define update_model update_model_8bpc
-#define find_bucket find_bucket_8bpc
-#define family family_8bpc
-#define BPC 8
-#define BPC_MASK 0xffU
-#define COMPRESS_IMP
-#define SET_r(pix, val) ((pix)->r = val)
-#define GET_r(pix) ((pix)->r)
-#define SET_g(pix, val) ((pix)->g = val)
-#define GET_g(pix) ((pix)->g)
-#define SET_b(pix, val) ((pix)->b = val)
-#define GET_b(pix) ((pix)->b)
-#define UNCOMPRESS_PIX_START(pix)
-#endif
-
-#ifdef QUIC_RGB16
-#undef QUIC_RGB16
-#define PIXEL rgb16_pixel_t
-#define FNAME(name) quic_rgb16_##name
-#define golomb_coding golomb_coding_5bpc
-#define golomb_decoding golomb_decoding_5bpc
-#define update_model update_model_5bpc
-#define find_bucket find_bucket_5bpc
-#define family family_5bpc
-#define BPC 5
-#define BPC_MASK 0x1fU
-#define COMPRESS_IMP
-#define SET_r(pix, val) (*(pix) = (*(pix) & ~(0x1f << 10)) | ((val) << 10))
-#define GET_r(pix) ((*(pix) >> 10) & 0x1f)
-#define SET_g(pix, val) (*(pix) = (*(pix) & ~(0x1f << 5)) | ((val) << 5))
-#define GET_g(pix) ((*(pix) >> 5) & 0x1f)
-#define SET_b(pix, val) (*(pix) = (*(pix) & ~0x1f) | (val))
-#define GET_b(pix) (*(pix) & 0x1f)
-#define UNCOMPRESS_PIX_START(pix) (*(pix) = 0)
-#endif
-
-#ifdef QUIC_RGB16_TO_32
-#undef QUIC_RGB16_TO_32
-#define PIXEL rgb32_pixel_t
-#define FNAME(name) quic_rgb16_to_32_##name
-#define golomb_coding golomb_coding_5bpc
-#define golomb_decoding golomb_decoding_5bpc
-#define update_model update_model_5bpc
-#define find_bucket find_bucket_5bpc
-#define family family_5bpc
-#define BPC 5
-#define BPC_MASK 0x1fU
-
-#define SET_r(pix, val) ((pix)->r = ((val) << 3) | (((val) & 0x1f) >> 2))
-#define GET_r(pix) ((pix)->r >> 3)
-#define SET_g(pix, val) ((pix)->g = ((val) << 3) | (((val) & 0x1f) >> 2))
-#define GET_g(pix) ((pix)->g >> 3)
-#define SET_b(pix, val) ((pix)->b = ((val) << 3) | (((val) & 0x1f) >> 2))
-#define GET_b(pix) ((pix)->b >> 3)
-#define UNCOMPRESS_PIX_START(pix) ((pix)->pad = 0)
-#endif
-
-#define SAME_PIXEL(p1, p2) \
- (GET_r(p1) == GET_r(p2) && GET_g(p1) == GET_g(p2) && \
- GET_b(p1) == GET_b(p2))
-
-
-#define _PIXEL_A(channel, curr) ((unsigned int)GET_##channel((curr) - 1))
-#define _PIXEL_B(channel, prev) ((unsigned int)GET_##channel(prev))
-#define _PIXEL_C(channel, prev) ((unsigned int)GET_##channel((prev) - 1))
-
-/* a */
-
-#define DECORELATE_0(channel, curr, bpc_mask)\
- family.xlatU2L[(unsigned)((int)GET_##channel(curr) - (int)_PIXEL_A(channel, curr)) & bpc_mask]
-
-#define CORELATE_0(channel, curr, correlate, bpc_mask)\
- ((family.xlatL2U[correlate] + _PIXEL_A(channel, curr)) & bpc_mask)
-
-#ifdef PRED_1
-
-/* (a+b)/2 */
-#define DECORELATE(channel, prev, curr, bpc_mask, r) \
- r = family.xlatU2L[(unsigned)((int)GET_##channel(curr) - (int)((_PIXEL_A(channel, curr) + \
- _PIXEL_B(channel, prev)) >> 1)) & bpc_mask]
-
-#define CORELATE(channel, prev, curr, correlate, bpc_mask, r) \
- SET_##channel(r, ((family.xlatL2U[correlate] + \
- (int)((_PIXEL_A(channel, curr) + _PIXEL_B(channel, prev)) >> 1)) & bpc_mask))
-#endif
-
-#ifdef PRED_2
-
-/* .75a+.75b-.5c */
-#define DECORELATE(channel, prev, curr, bpc_mask, r) { \
- int p = ((int)(3 * (_PIXEL_A(channel, curr) + _PIXEL_B(channel, prev))) - \
- (int)(_PIXEL_C(channel, prev) << 1)) >> 2; \
- if (p < 0) { \
- p = 0; \
- } else if ((unsigned)p > bpc_mask) { \
- p = bpc_mask; \
- } \
- r = family.xlatU2L[(unsigned)((int)GET_##channel(curr) - p) & bpc_mask]; \
-}
-
-#define CORELATE(channel, prev, curr, correlate, bpc_mask, r) { \
- const int p = ((int)(3 * (_PIXEL_A(channel, curr) + _PIXEL_B(channel, prev))) - \
- (int)(_PIXEL_C(channel, prev) << 1) ) >> 2; \
- const unsigned int s = family.xlatL2U[correlate]; \
- if (!(p & ~bpc_mask)) { \
- SET_##channel(r, (s + (unsigned)p) & bpc_mask); \
- } else if (p < 0) { \
- SET_##channel(r, s); \
- } else { \
- SET_##channel(r, (s + bpc_mask) & bpc_mask); \
- } \
-}
-
-#endif
-
-
-#define COMPRESS_ONE_ROW0_0(channel) \
- correlate_row_##channel[0] = family.xlatU2L[GET_##channel(cur_row)]; \
- golomb_coding(correlate_row_##channel[0], find_bucket(channel_##channel, \
- correlate_row_##channel[-1])->bestcode, \
- &codeword, &codewordlen); \
- encode(encoder, codeword, codewordlen);
-
-#define COMPRESS_ONE_ROW0(channel, index) \
- correlate_row_##channel[index] = DECORELATE_0(channel, &cur_row[index], bpc_mask); \
- golomb_coding(correlate_row_##channel[index], find_bucket(channel_##channel, \
- correlate_row_##channel[index -1])->bestcode, \
- &codeword, &codewordlen); \
- encode(encoder, codeword, codewordlen);
-
-#define UPDATE_MODEL(index) \
- update_model(&encoder->rgb_state, find_bucket(channel_r, correlate_row_r[index - 1]), \
- correlate_row_r[index], bpc); \
- update_model(&encoder->rgb_state, find_bucket(channel_g, correlate_row_g[index - 1]), \
- correlate_row_g[index], bpc); \
- update_model(&encoder->rgb_state, find_bucket(channel_b, correlate_row_b[index - 1]), \
- correlate_row_b[index], bpc);
-
-
-#ifdef RLE_PRED_1
-#define RLE_PRED_1_IMP \
-if (SAME_PIXEL(&cur_row[i - 1], &prev_row[i])) { \
- if (run_index != i && SAME_PIXEL(&prev_row[i - 1], &prev_row[i]) && \
- i + 1 < end && SAME_PIXEL(&prev_row[i], &prev_row[i + 1])) { \
- goto do_run; \
- } \
-}
-#else
-#define RLE_PRED_1_IMP
-#endif
-
-#ifdef RLE_PRED_2
-#define RLE_PRED_2_IMP \
-if (SAME_PIXEL(&prev_row[i - 1], &prev_row[i])) { \
- if (run_index != i && i > 2 && SAME_PIXEL(&cur_row[i - 1], &cur_row[i - 2])) { \
- goto do_run; \
- } \
-}
-#else
-#define RLE_PRED_2_IMP
-#endif
-
-#ifdef RLE_PRED_3
-#define RLE_PRED_3_IMP \
-if (i > 1 && SAME_PIXEL(&cur_row[i - 1], &cur_row[i - 2]) && i != run_index) { \
- goto do_run; \
-}
-#else
-#define RLE_PRED_3_IMP
-#endif
-
-#ifdef COMPRESS_IMP
-
-static void FNAME(compress_row0_seg)(Encoder *encoder, int i,
- const PIXEL * const cur_row,
- const int end,
- const unsigned int waitmask,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- Channel * const channel_r = encoder->channels;
- Channel * const channel_g = channel_r + 1;
- Channel * const channel_b = channel_g + 1;
-
- BYTE * const correlate_row_r = channel_r->correlate_row;
- BYTE * const correlate_row_g = channel_g->correlate_row;
- BYTE * const correlate_row_b = channel_b->correlate_row;
- int stopidx;
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (!i) {
- unsigned int codeword, codewordlen;
-
- COMPRESS_ONE_ROW0_0(r);
- COMPRESS_ONE_ROW0_0(g);
- COMPRESS_ONE_ROW0_0(b);
-
- if (encoder->rgb_state.waitcnt) {
- encoder->rgb_state.waitcnt--;
- } else {
- encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- UPDATE_MODEL(0);
- }
- stopidx = ++i + encoder->rgb_state.waitcnt;
- } else {
- stopidx = i + encoder->rgb_state.waitcnt;
- }
-
- while (stopidx < end) {
- for (; i <= stopidx; i++) {
- unsigned int codeword, codewordlen;
- COMPRESS_ONE_ROW0(r, i);
- COMPRESS_ONE_ROW0(g, i);
- COMPRESS_ONE_ROW0(b, i);
- }
-
- UPDATE_MODEL(stopidx);
- stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codeword, codewordlen;
-
- COMPRESS_ONE_ROW0(r, i);
- COMPRESS_ONE_ROW0(g, i);
- COMPRESS_ONE_ROW0(b, i);
- }
- encoder->rgb_state.waitcnt = stopidx - end;
-}
-
-static void FNAME(compress_row0)(Encoder *encoder, const PIXEL *cur_row,
- unsigned int width)
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- int pos = 0;
-
- while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
- if (encoder->rgb_state.wmileft) {
- FNAME(compress_row0_seg)(encoder, pos, cur_row, pos + encoder->rgb_state.wmileft,
- bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
- width -= encoder->rgb_state.wmileft;
- pos += encoder->rgb_state.wmileft;
- }
-
- encoder->rgb_state.wmidx++;
- set_wm_trigger(&encoder->rgb_state);
- encoder->rgb_state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(compress_row0_seg)(encoder, pos, cur_row, pos + width,
- bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
- if (wmimax > (int)encoder->rgb_state.wmidx) {
- encoder->rgb_state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
- ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-#define COMPRESS_ONE_0(channel) \
- correlate_row_##channel[0] = family.xlatU2L[(unsigned)((int)GET_##channel(cur_row) - \
- (int)GET_##channel(prev_row) ) & bpc_mask]; \
- golomb_coding(correlate_row_##channel[0], \
- find_bucket(channel_##channel, correlate_row_##channel[-1])->bestcode, \
- &codeword, &codewordlen); \
- encode(encoder, codeword, codewordlen);
-
-#define COMPRESS_ONE(channel, index) \
- DECORELATE(channel, &prev_row[index], &cur_row[index],bpc_mask, \
- correlate_row_##channel[index]); \
- golomb_coding(correlate_row_##channel[index], \
- find_bucket(channel_##channel, correlate_row_##channel[index - 1])->bestcode, \
- &codeword, &codewordlen); \
- encode(encoder, codeword, codewordlen);
-
-static void FNAME(compress_row_seg)(Encoder *encoder, int i,
- const PIXEL * const prev_row,
- const PIXEL * const cur_row,
- const int end,
- const unsigned int waitmask,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- Channel * const channel_r = encoder->channels;
- Channel * const channel_g = channel_r + 1;
- Channel * const channel_b = channel_g + 1;
-
- BYTE * const correlate_row_r = channel_r->correlate_row;
- BYTE * const correlate_row_g = channel_g->correlate_row;
- BYTE * const correlate_row_b = channel_b->correlate_row;
- int stopidx;
-#ifdef RLE
- int run_index = 0;
- int run_size;
-#endif
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (!i) {
- unsigned int codeword, codewordlen;
-
- COMPRESS_ONE_0(r);
- COMPRESS_ONE_0(g);
- COMPRESS_ONE_0(b);
-
- if (encoder->rgb_state.waitcnt) {
- encoder->rgb_state.waitcnt--;
- } else {
- encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- UPDATE_MODEL(0);
- }
- stopidx = ++i + encoder->rgb_state.waitcnt;
- } else {
- stopidx = i + encoder->rgb_state.waitcnt;
- }
- for (;;) {
- while (stopidx < end) {
- for (; i <= stopidx; i++) {
- unsigned int codeword, codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- COMPRESS_ONE(r, i);
- COMPRESS_ONE(g, i);
- COMPRESS_ONE(b, i);
- }
-
- UPDATE_MODEL(stopidx);
- stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codeword, codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- COMPRESS_ONE(r, i);
- COMPRESS_ONE(g, i);
- COMPRESS_ONE(b, i);
- }
- encoder->rgb_state.waitcnt = stopidx - end;
-
- return;
-
-#ifdef RLE
-do_run:
- run_index = i;
- encoder->rgb_state.waitcnt = stopidx - i;
- run_size = 0;
-
- while (SAME_PIXEL(&cur_row[i], &cur_row[i - 1])) {
- run_size++;
- if (++i == end) {
- encode_run(encoder, run_size);
- return;
- }
- }
- encode_run(encoder, run_size);
- stopidx = i + encoder->rgb_state.waitcnt;
-#endif
- }
-}
-
-static void FNAME(compress_row)(Encoder *encoder,
- const PIXEL * const prev_row,
- const PIXEL * const cur_row,
- unsigned int width)
-
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- unsigned int pos = 0;
-
- while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
- if (encoder->rgb_state.wmileft) {
- FNAME(compress_row_seg)(encoder, pos, prev_row, cur_row,
- pos + encoder->rgb_state.wmileft,
- bppmask[encoder->rgb_state.wmidx],
- bpc, bpc_mask);
- width -= encoder->rgb_state.wmileft;
- pos += encoder->rgb_state.wmileft;
- }
-
- encoder->rgb_state.wmidx++;
- set_wm_trigger(&encoder->rgb_state);
- encoder->rgb_state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(compress_row_seg)(encoder, pos, prev_row, cur_row, pos + width,
- bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
- if (wmimax > (int)encoder->rgb_state.wmidx) {
- encoder->rgb_state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
- ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-#endif
-
-#define UNCOMPRESS_ONE_ROW0_0(channel) \
- correlate_row_##channel[0] = (BYTE)golomb_decoding(find_bucket(channel_##channel, \
- correlate_row_##channel[-1])->bestcode, \
- encoder->io_word, &codewordlen); \
- SET_##channel(&cur_row[0], (BYTE)family.xlatL2U[correlate_row_##channel[0]]); \
- decode_eatbits(encoder, codewordlen);
-
-#define UNCOMPRESS_ONE_ROW0(channel) \
- correlate_row_##channel[i] = (BYTE)golomb_decoding(find_bucket(channel_##channel, \
- correlate_row_##channel[i - 1])->bestcode, \
- encoder->io_word, \
- &codewordlen); \
- SET_##channel(&cur_row[i], CORELATE_0(channel, &cur_row[i], correlate_row_##channel[i], \
- bpc_mask)); \
- decode_eatbits(encoder, codewordlen);
-
-static void FNAME(uncompress_row0_seg)(Encoder *encoder, int i,
- PIXEL * const cur_row,
- const int end,
- const unsigned int waitmask,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- Channel * const channel_r = encoder->channels;
- Channel * const channel_g = channel_r + 1;
- Channel * const channel_b = channel_g + 1;
-
- BYTE * const correlate_row_r = channel_r->correlate_row;
- BYTE * const correlate_row_g = channel_g->correlate_row;
- BYTE * const correlate_row_b = channel_b->correlate_row;
- int stopidx;
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (!i) {
- unsigned int codewordlen;
-
- UNCOMPRESS_PIX_START(&cur_row[i]);
- UNCOMPRESS_ONE_ROW0_0(r);
- UNCOMPRESS_ONE_ROW0_0(g);
- UNCOMPRESS_ONE_ROW0_0(b);
-
- if (encoder->rgb_state.waitcnt) {
- --encoder->rgb_state.waitcnt;
- } else {
- encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- UPDATE_MODEL(0);
- }
- stopidx = ++i + encoder->rgb_state.waitcnt;
- } else {
- stopidx = i + encoder->rgb_state.waitcnt;
- }
-
- while (stopidx < end) {
- for (; i <= stopidx; i++) {
- unsigned int codewordlen;
-
- UNCOMPRESS_PIX_START(&cur_row[i]);
- UNCOMPRESS_ONE_ROW0(r);
- UNCOMPRESS_ONE_ROW0(g);
- UNCOMPRESS_ONE_ROW0(b);
- }
- UPDATE_MODEL(stopidx);
- stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codewordlen;
-
- UNCOMPRESS_PIX_START(&cur_row[i]);
- UNCOMPRESS_ONE_ROW0(r);
- UNCOMPRESS_ONE_ROW0(g);
- UNCOMPRESS_ONE_ROW0(b);
- }
- encoder->rgb_state.waitcnt = stopidx - end;
-}
-
-static void FNAME(uncompress_row0)(Encoder *encoder,
- PIXEL * const cur_row,
- unsigned int width)
-
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- unsigned int pos = 0;
-
- while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
- if (encoder->rgb_state.wmileft) {
- FNAME(uncompress_row0_seg)(encoder, pos, cur_row,
- pos + encoder->rgb_state.wmileft,
- bppmask[encoder->rgb_state.wmidx],
- bpc, bpc_mask);
- pos += encoder->rgb_state.wmileft;
- width -= encoder->rgb_state.wmileft;
- }
-
- encoder->rgb_state.wmidx++;
- set_wm_trigger(&encoder->rgb_state);
- encoder->rgb_state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(uncompress_row0_seg)(encoder, pos, cur_row, pos + width,
- bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
- if (wmimax > (int)encoder->rgb_state.wmidx) {
- encoder->rgb_state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
- ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-#define UNCOMPRESS_ONE_0(channel) \
- correlate_row_##channel[0] = (BYTE)golomb_decoding(find_bucket(channel_##channel, \
- correlate_row_##channel[-1])->bestcode, \
- encoder->io_word, &codewordlen); \
- SET_##channel(&cur_row[0], (family.xlatL2U[correlate_row_##channel[0]] + \
- GET_##channel(prev_row)) & bpc_mask); \
- decode_eatbits(encoder, codewordlen);
-
-#define UNCOMPRESS_ONE(channel) \
- correlate_row_##channel[i] = (BYTE)golomb_decoding(find_bucket(channel_##channel, \
- correlate_row_##channel[i - 1])->bestcode, \
- encoder->io_word, \
- &codewordlen); \
- CORELATE(channel, &prev_row[i], &cur_row[i], correlate_row_##channel[i], bpc_mask, \
- &cur_row[i]); \
- decode_eatbits(encoder, codewordlen);
-
-static void FNAME(uncompress_row_seg)(Encoder *encoder,
- const PIXEL * const prev_row,
- PIXEL * const cur_row,
- int i,
- const int end,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- Channel * const channel_r = encoder->channels;
- Channel * const channel_g = channel_r + 1;
- Channel * const channel_b = channel_g + 1;
-
- BYTE * const correlate_row_r = channel_r->correlate_row;
- BYTE * const correlate_row_g = channel_g->correlate_row;
- BYTE * const correlate_row_b = channel_b->correlate_row;
- const unsigned int waitmask = bppmask[encoder->rgb_state.wmidx];
- int stopidx;
-#ifdef RLE
- int run_index = 0;
- int run_end;
-#endif
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (!i) {
- unsigned int codewordlen;
-
- UNCOMPRESS_PIX_START(&cur_row[i]);
- UNCOMPRESS_ONE_0(r);
- UNCOMPRESS_ONE_0(g);
- UNCOMPRESS_ONE_0(b);
-
- if (encoder->rgb_state.waitcnt) {
- --encoder->rgb_state.waitcnt;
- } else {
- encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- UPDATE_MODEL(0);
- }
- stopidx = ++i + encoder->rgb_state.waitcnt;
- } else {
- stopidx = i + encoder->rgb_state.waitcnt;
- }
- for (;;) {
- while (stopidx < end) {
- for (; i <= stopidx; i++) {
- unsigned int codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- UNCOMPRESS_PIX_START(&cur_row[i]);
- UNCOMPRESS_ONE(r);
- UNCOMPRESS_ONE(g);
- UNCOMPRESS_ONE(b);
- }
-
- UPDATE_MODEL(stopidx);
-
- stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- UNCOMPRESS_PIX_START(&cur_row[i]);
- UNCOMPRESS_ONE(r);
- UNCOMPRESS_ONE(g);
- UNCOMPRESS_ONE(b);
- }
-
- encoder->rgb_state.waitcnt = stopidx - end;
-
- return;
-
-#ifdef RLE
-do_run:
- encoder->rgb_state.waitcnt = stopidx - i;
- run_index = i;
- run_end = i + decode_run(encoder);
-
- for (; i < run_end; i++) {
- UNCOMPRESS_PIX_START(&cur_row[i]);
- SET_r(&cur_row[i], GET_r(&cur_row[i - 1]));
- SET_g(&cur_row[i], GET_g(&cur_row[i - 1]));
- SET_b(&cur_row[i], GET_b(&cur_row[i - 1]));
- }
-
- if (i == end) {
- return;
- }
-
- stopidx = i + encoder->rgb_state.waitcnt;
-#endif
- }
-}
-
-static void FNAME(uncompress_row)(Encoder *encoder,
- const PIXEL * const prev_row,
- PIXEL * const cur_row,
- unsigned int width)
-
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- unsigned int pos = 0;
-
- while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
- if (encoder->rgb_state.wmileft) {
- FNAME(uncompress_row_seg)(encoder, prev_row, cur_row, pos,
- pos + encoder->rgb_state.wmileft, bpc, bpc_mask);
- pos += encoder->rgb_state.wmileft;
- width -= encoder->rgb_state.wmileft;
- }
-
- encoder->rgb_state.wmidx++;
- set_wm_trigger(&encoder->rgb_state);
- encoder->rgb_state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(uncompress_row_seg)(encoder, prev_row, cur_row, pos,
- pos + width, bpc, bpc_mask);
- if (wmimax > (int)encoder->rgb_state.wmidx) {
- encoder->rgb_state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
- ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-#undef PIXEL
-#undef FNAME
-#undef _PIXEL_A
-#undef _PIXEL_B
-#undef _PIXEL_C
-#undef SAME_PIXEL
-#undef RLE_PRED_1_IMP
-#undef RLE_PRED_2_IMP
-#undef RLE_PRED_3_IMP
-#undef UPDATE_MODEL
-#undef DECORELATE_0
-#undef DECORELATE
-#undef COMPRESS_ONE_ROW0_0
-#undef COMPRESS_ONE_ROW0
-#undef COMPRESS_ONE_0
-#undef COMPRESS_ONE
-#undef CORELATE_0
-#undef CORELATE
-#undef UNCOMPRESS_ONE_ROW0_0
-#undef UNCOMPRESS_ONE_ROW0
-#undef UNCOMPRESS_ONE_0
-#undef UNCOMPRESS_ONE
-#undef golomb_coding
-#undef golomb_decoding
-#undef update_model
-#undef find_bucket
-#undef family
-#undef BPC
-#undef BPC_MASK
-#undef COMPRESS_IMP
-#undef SET_r
-#undef GET_r
-#undef SET_g
-#undef GET_g
-#undef SET_b
-#undef GET_b
-#undef UNCOMPRESS_PIX_START
diff --git a/common/quic_tmpl.c b/common/quic_tmpl.c
deleted file mode 100644
index 6acd504..0000000
--- a/common/quic_tmpl.c
+++ /dev/null
@@ -1,635 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef ONE_BYTE
-#undef ONE_BYTE
-#define FNAME(name) quic_one_##name
-#define PIXEL one_byte_t
-#endif
-
-#ifdef THREE_BYTE
-#undef THREE_BYTE
-#define FNAME(name) quic_three_##name
-#define PIXEL three_bytes_t
-#endif
-
-#ifdef FOUR_BYTE
-#undef FOUR_BYTE
-#define FNAME(name) quic_four_##name
-#define PIXEL four_bytes_t
-#endif
-
-#define golomb_coding golomb_coding_8bpc
-#define golomb_decoding golomb_decoding_8bpc
-#define update_model update_model_8bpc
-#define find_bucket find_bucket_8bpc
-#define family family_8bpc
-
-#define BPC 8
-#define BPC_MASK 0xffU
-
-#define _PIXEL_A ((unsigned int)curr[-1].a)
-#define _PIXEL_B ((unsigned int)prev[0].a)
-#define _PIXEL_C ((unsigned int)prev[-1].a)
-
-#ifdef RLE_PRED_1
-#define RLE_PRED_1_IMP \
-if (cur_row[i - 1].a == prev_row[i].a) { \
- if (run_index != i && prev_row[i - 1].a == prev_row[i].a && \
- i + 1 < end && prev_row[i].a == prev_row[i + 1].a) { \
- goto do_run; \
- } \
-}
-#else
-#define RLE_PRED_1_IMP
-#endif
-
-#ifdef RLE_PRED_2
-#define RLE_PRED_2_IMP \
-if (prev_row[i - 1].a == prev_row[i].a) { \
- if (run_index != i && i > 2 && cur_row[i - 1].a == cur_row[i - 2].a) { \
- goto do_run; \
- } \
-}
-#else
-#define RLE_PRED_2_IMP
-#endif
-
-#ifdef RLE_PRED_3
-#define RLE_PRED_3_IMP \
-if (i > 1 && cur_row[i - 1].a == cur_row[i - 2].a && i != run_index) { \
- goto do_run; \
-}
-#else
-#define RLE_PRED_3_IMP
-#endif
-
-/* a */
-static INLINE BYTE FNAME(decorelate_0)(const PIXEL * const curr, const unsigned int bpc_mask)
-{
- return family.xlatU2L[(unsigned)((int)curr[0].a - (int)_PIXEL_A) & bpc_mask];
-}
-
-static INLINE void FNAME(corelate_0)(PIXEL *curr, const BYTE corelate,
- const unsigned int bpc_mask)
-{
- curr->a = (family.xlatL2U[corelate] + _PIXEL_A) & bpc_mask;
-}
-
-#ifdef PRED_1
-
-/* (a+b)/2 */
-static INLINE BYTE FNAME(decorelate)(const PIXEL *const prev, const PIXEL * const curr,
- const unsigned int bpc_mask)
-{
- return family.xlatU2L[(unsigned)((int)curr->a - (int)((_PIXEL_A + _PIXEL_B) >> 1)) & bpc_mask];
-}
-
-
-static INLINE void FNAME(corelate)(const PIXEL *prev, PIXEL *curr, const BYTE corelate,
- const unsigned int bpc_mask)
-{
- curr->a = (family.xlatL2U[corelate] + (int)((_PIXEL_A + _PIXEL_B) >> 1)) & bpc_mask;
-}
-
-#endif
-
-#ifdef PRED_2
-
-/* .75a+.75b-.5c */
-static INLINE BYTE FNAME(decorelate)(const PIXEL *const prev, const PIXEL * const curr,
- const unsigned int bpc_mask)
-{
- int p = ((int)(3 * (_PIXEL_A + _PIXEL_B)) - (int)(_PIXEL_C << 1)) >> 2;
-
- if (p < 0) {
- p = 0;
- } else if ((unsigned)p > bpc_mask) {
- p = bpc_mask;
- }
-
- {
- return family.xlatU2L[(unsigned)((int)curr->a - p) & bpc_mask];
- }
-}
-
-static INLINE void FNAME(corelate)(const PIXEL *prev, PIXEL *curr, const BYTE corelate,
- const unsigned int bpc_mask)
-{
- const int p = ((int)(3 * (_PIXEL_A + _PIXEL_B)) - (int)(_PIXEL_C << 1)) >> 2;
- const unsigned int s = family.xlatL2U[corelate];
-
- if (!(p & ~bpc_mask)) {
- curr->a = (s + (unsigned)p) & bpc_mask;
- } else if (p < 0) {
- curr->a = s;
- } else {
- curr->a = (s + bpc_mask) & bpc_mask;
- }
-}
-
-#endif
-
-static void FNAME(compress_row0_seg)(Encoder *encoder, Channel *channel, int i,
- const PIXEL * const cur_row,
- const int end,
- const unsigned int waitmask,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- BYTE * const decorelate_drow = channel->correlate_row;
- int stopidx;
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (i == 0) {
- unsigned int codeword, codewordlen;
-
- decorelate_drow[0] = family.xlatU2L[cur_row->a];
- golomb_coding(decorelate_drow[0], find_bucket(channel, decorelate_drow[-1])->bestcode,
- &codeword, &codewordlen);
- encode(encoder, codeword, codewordlen);
-
- if (channel->state.waitcnt) {
- channel->state.waitcnt--;
- } else {
- channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
- update_model(&channel->state, find_bucket(channel, decorelate_drow[-1]),
- decorelate_drow[i], bpc);
- }
- stopidx = ++i + channel->state.waitcnt;
- } else {
- stopidx = i + channel->state.waitcnt;
- }
-
- while (stopidx < end) {
- for (; i <= stopidx; i++) {
- unsigned int codeword, codewordlen;
- decorelate_drow[i] = FNAME(decorelate_0)(&cur_row[i], bpc_mask);
- golomb_coding(decorelate_drow[i],
- find_bucket(channel, decorelate_drow[i - 1])->bestcode, &codeword,
- &codewordlen);
- encode(encoder, codeword, codewordlen);
- }
-
- update_model(&channel->state, find_bucket(channel, decorelate_drow[stopidx - 1]),
- decorelate_drow[stopidx], bpc);
- stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codeword, codewordlen;
- decorelate_drow[i] = FNAME(decorelate_0)(&cur_row[i], bpc_mask);
- golomb_coding(decorelate_drow[i], find_bucket(channel, decorelate_drow[i - 1])->bestcode,
- &codeword, &codewordlen);
- encode(encoder, codeword, codewordlen);
- }
- channel->state.waitcnt = stopidx - end;
-}
-
-static void FNAME(compress_row0)(Encoder *encoder, Channel *channel, const PIXEL *cur_row,
- unsigned int width)
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- int pos = 0;
-
- while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
- if (channel->state.wmileft) {
- FNAME(compress_row0_seg)(encoder, channel, pos, cur_row, pos + channel->state.wmileft,
- bppmask[channel->state.wmidx], bpc, bpc_mask);
- width -= channel->state.wmileft;
- pos += channel->state.wmileft;
- }
-
- channel->state.wmidx++;
- set_wm_trigger(&channel->state);
- channel->state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(compress_row0_seg)(encoder, channel, pos, cur_row, pos + width,
- bppmask[channel->state.wmidx], bpc, bpc_mask);
- if (wmimax > (int)channel->state.wmidx) {
- channel->state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
- ASSERT(encoder->usr, channel->state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-static void FNAME(compress_row_seg)(Encoder *encoder, Channel *channel, int i,
- const PIXEL * const prev_row,
- const PIXEL * const cur_row,
- const int end,
- const unsigned int waitmask,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- BYTE * const decorelate_drow = channel->correlate_row;
- int stopidx;
-#ifdef RLE
- int run_index = 0;
- int run_size;
-#endif
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (!i) {
- unsigned int codeword, codewordlen;
-
- decorelate_drow[0] = family.xlatU2L[(unsigned)((int)cur_row->a -
- (int)prev_row->a) & bpc_mask];
-
- golomb_coding(decorelate_drow[0],
- find_bucket(channel, decorelate_drow[-1])->bestcode,
- &codeword,
- &codewordlen);
- encode(encoder, codeword, codewordlen);
-
- if (channel->state.waitcnt) {
- channel->state.waitcnt--;
- } else {
- channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
- update_model(&channel->state, find_bucket(channel, decorelate_drow[-1]),
- decorelate_drow[0], bpc);
- }
- stopidx = ++i + channel->state.waitcnt;
- } else {
- stopidx = i + channel->state.waitcnt;
- }
- for (;;) {
- while (stopidx < end) {
- for (; i <= stopidx; i++) {
- unsigned int codeword, codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- decorelate_drow[i] = FNAME(decorelate)(&prev_row[i], &cur_row[i], bpc_mask);
- golomb_coding(decorelate_drow[i],
- find_bucket(channel, decorelate_drow[i - 1])->bestcode, &codeword,
- &codewordlen);
- encode(encoder, codeword, codewordlen);
- }
-
- update_model(&channel->state, find_bucket(channel, decorelate_drow[stopidx - 1]),
- decorelate_drow[stopidx], bpc);
- stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codeword, codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- decorelate_drow[i] = FNAME(decorelate)(&prev_row[i], &cur_row[i], bpc_mask);
- golomb_coding(decorelate_drow[i], find_bucket(channel,
- decorelate_drow[i - 1])->bestcode,
- &codeword, &codewordlen);
- encode(encoder, codeword, codewordlen);
- }
- channel->state.waitcnt = stopidx - end;
-
- return;
-
-#ifdef RLE
-do_run:
- run_index = i;
- channel->state.waitcnt = stopidx - i;
- run_size = 0;
-
- while (cur_row[i].a == cur_row[i - 1].a) {
- run_size++;
- if (++i == end) {
-#ifdef RLE_STAT
- encode_channel_run(encoder, channel, run_size);
-#else
- encode_run(encoder, run_size);
-#endif
- return;
- }
- }
-#ifdef RLE_STAT
- encode_channel_run(encoder, channel, run_size);
-#else
- encode_run(encoder, run_size);
-#endif
- stopidx = i + channel->state.waitcnt;
-#endif
- }
-}
-
-static void FNAME(compress_row)(Encoder *encoder, Channel *channel,
- const PIXEL * const prev_row,
- const PIXEL * const cur_row,
- unsigned int width)
-
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- unsigned int pos = 0;
-
- while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
- if (channel->state.wmileft) {
- FNAME(compress_row_seg)(encoder, channel, pos, prev_row, cur_row,
- pos + channel->state.wmileft, bppmask[channel->state.wmidx],
- bpc, bpc_mask);
- width -= channel->state.wmileft;
- pos += channel->state.wmileft;
- }
-
- channel->state.wmidx++;
- set_wm_trigger(&channel->state);
- channel->state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(compress_row_seg)(encoder, channel, pos, prev_row, cur_row, pos + width,
- bppmask[channel->state.wmidx], bpc, bpc_mask);
- if (wmimax > (int)channel->state.wmidx) {
- channel->state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
- ASSERT(encoder->usr, channel->state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-static void FNAME(uncompress_row0_seg)(Encoder *encoder, Channel *channel, int i,
- BYTE * const correlate_row,
- PIXEL * const cur_row,
- const int end,
- const unsigned int waitmask,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- int stopidx;
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (i == 0) {
- unsigned int codewordlen;
-
- correlate_row[0] = (BYTE)golomb_decoding(find_bucket(channel,
- correlate_row[-1])->bestcode,
- encoder->io_word, &codewordlen);
- cur_row[0].a = (BYTE)family.xlatL2U[correlate_row[0]];
- decode_eatbits(encoder, codewordlen);
-
- if (channel->state.waitcnt) {
- --channel->state.waitcnt;
- } else {
- channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
- update_model(&channel->state, find_bucket(channel, correlate_row[-1]),
- correlate_row[0], bpc);
- }
- stopidx = ++i + channel->state.waitcnt;
- } else {
- stopidx = i + channel->state.waitcnt;
- }
-
- while (stopidx < end) {
- struct s_bucket * pbucket = NULL;
-
- for (; i <= stopidx; i++) {
- unsigned int codewordlen;
-
- pbucket = find_bucket(channel, correlate_row[i - 1]);
- correlate_row[i] = (BYTE)golomb_decoding(pbucket->bestcode, encoder->io_word,
- &codewordlen);
- FNAME(corelate_0)(&cur_row[i], correlate_row[i], bpc_mask);
- decode_eatbits(encoder, codewordlen);
- }
-
- update_model(&channel->state, pbucket, correlate_row[stopidx], bpc);
-
- stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codewordlen;
-
- correlate_row[i] = (BYTE)golomb_decoding(find_bucket(channel,
- correlate_row[i - 1])->bestcode,
- encoder->io_word, &codewordlen);
- FNAME(corelate_0)(&cur_row[i], correlate_row[i], bpc_mask);
- decode_eatbits(encoder, codewordlen);
- }
- channel->state.waitcnt = stopidx - end;
-}
-
-static void FNAME(uncompress_row0)(Encoder *encoder, Channel *channel,
- PIXEL * const cur_row,
- unsigned int width)
-
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- BYTE * const correlate_row = channel->correlate_row;
- unsigned int pos = 0;
-
- while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
- if (channel->state.wmileft) {
- FNAME(uncompress_row0_seg)(encoder, channel, pos, correlate_row, cur_row,
- pos + channel->state.wmileft, bppmask[channel->state.wmidx],
- bpc, bpc_mask);
- pos += channel->state.wmileft;
- width -= channel->state.wmileft;
- }
-
- channel->state.wmidx++;
- set_wm_trigger(&channel->state);
- channel->state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(uncompress_row0_seg)(encoder, channel, pos, correlate_row, cur_row, pos + width,
- bppmask[channel->state.wmidx], bpc, bpc_mask);
- if (wmimax > (int)channel->state.wmidx) {
- channel->state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
- ASSERT(encoder->usr, channel->state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-static void FNAME(uncompress_row_seg)(Encoder *encoder, Channel *channel,
- BYTE *correlate_row,
- const PIXEL * const prev_row,
- PIXEL * const cur_row,
- int i,
- const int end,
- const unsigned int bpc,
- const unsigned int bpc_mask)
-{
- const unsigned int waitmask = bppmask[channel->state.wmidx];
- int stopidx;
-#ifdef RLE
- int run_index = 0;
- int run_end;
-#endif
-
- ASSERT(encoder->usr, end - i > 0);
-
- if (i == 0) {
- unsigned int codewordlen;
-
- correlate_row[0] = (BYTE)golomb_decoding(find_bucket(channel, correlate_row[-1])->bestcode,
- encoder->io_word, &codewordlen);
- cur_row[0].a = (family.xlatL2U[correlate_row[0]] + prev_row[0].a) & bpc_mask;
- decode_eatbits(encoder, codewordlen);
-
- if (channel->state.waitcnt) {
- --channel->state.waitcnt;
- } else {
- channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
- update_model(&channel->state, find_bucket(channel, correlate_row[-1]),
- correlate_row[0], bpc);
- }
- stopidx = ++i + channel->state.waitcnt;
- } else {
- stopidx = i + channel->state.waitcnt;
- }
- for (;;) {
- while (stopidx < end) {
- struct s_bucket * pbucket = NULL;
-
- for (; i <= stopidx; i++) {
- unsigned int codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- pbucket = find_bucket(channel, correlate_row[i - 1]);
- correlate_row[i] = (BYTE)golomb_decoding(pbucket->bestcode, encoder->io_word,
- &codewordlen);
- FNAME(corelate)(&prev_row[i], &cur_row[i], correlate_row[i], bpc_mask);
- decode_eatbits(encoder, codewordlen);
- }
-
- update_model(&channel->state, pbucket, correlate_row[stopidx], bpc);
-
- stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
- }
-
- for (; i < end; i++) {
- unsigned int codewordlen;
-#ifdef RLE
- RLE_PRED_1_IMP;
- RLE_PRED_2_IMP;
- RLE_PRED_3_IMP;
-#endif
- correlate_row[i] = (BYTE)golomb_decoding(find_bucket(channel,
- correlate_row[i - 1])->bestcode,
- encoder->io_word, &codewordlen);
- FNAME(corelate)(&prev_row[i], &cur_row[i], correlate_row[i], bpc_mask);
- decode_eatbits(encoder, codewordlen);
- }
-
- channel->state.waitcnt = stopidx - end;
-
- return;
-
-#ifdef RLE
-do_run:
- channel->state.waitcnt = stopidx - i;
- run_index = i;
-#ifdef RLE_STAT
- run_end = i + decode_channel_run(encoder, channel);
-#else
- run_end = i + decode_run(encoder);
-#endif
-
- for (; i < run_end; i++) {
- cur_row[i].a = cur_row[i - 1].a;
- }
-
- if (i == end) {
- return;
- }
-
- stopidx = i + channel->state.waitcnt;
-#endif
- }
-}
-
-static void FNAME(uncompress_row)(Encoder *encoder, Channel *channel,
- const PIXEL * const prev_row,
- PIXEL * const cur_row,
- unsigned int width)
-
-{
- const unsigned int bpc = BPC;
- const unsigned int bpc_mask = BPC_MASK;
- BYTE * const correlate_row = channel->correlate_row;
- unsigned int pos = 0;
-
- while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
- if (channel->state.wmileft) {
- FNAME(uncompress_row_seg)(encoder, channel, correlate_row, prev_row, cur_row, pos,
- pos + channel->state.wmileft, bpc, bpc_mask);
- pos += channel->state.wmileft;
- width -= channel->state.wmileft;
- }
-
- channel->state.wmidx++;
- set_wm_trigger(&channel->state);
- channel->state.wmileft = wminext;
- }
-
- if (width) {
- FNAME(uncompress_row_seg)(encoder, channel, correlate_row, prev_row, cur_row, pos,
- pos + width, bpc, bpc_mask);
- if (wmimax > (int)channel->state.wmidx) {
- channel->state.wmileft -= width;
- }
- }
-
- ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
- ASSERT(encoder->usr, channel->state.wmidx <= 32);
- ASSERT(encoder->usr, wminext > 0);
-}
-
-#undef PIXEL
-#undef FNAME
-#undef _PIXEL_A
-#undef _PIXEL_B
-#undef _PIXEL_C
-#undef RLE_PRED_1_IMP
-#undef RLE_PRED_2_IMP
-#undef RLE_PRED_3_IMP
-#undef golomb_coding
-#undef golomb_deoding
-#undef update_model
-#undef find_bucket
-#undef family
-#undef BPC
-#undef BPC_MASK
diff --git a/common/rect.h b/common/rect.h
deleted file mode 100644
index ef265cd..0000000
--- a/common/rect.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_RECT
-#define _H_RECT
-
-#include "draw.h"
-#include <spice/macros.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static INLINE void rect_sect(SpiceRect* r, const SpiceRect* bounds)
-{
- r->left = MAX(r->left, bounds->left);
- r->right = MIN(r->right, bounds->right);
- r->right = MAX(r->left, r->right);
-
- r->top = MAX(r->top, bounds->top);
- r->bottom = MIN(r->bottom, bounds->bottom);
- r->bottom = MAX(r->top, r->bottom);
-}
-
-static INLINE void rect_offset(SpiceRect* r, int dx, int dy)
-{
- r->left += dx;
- r->right += dx;
- r->top += dy;
- r->bottom += dy;
-}
-
-static INLINE int rect_is_empty(const SpiceRect* r)
-{
- return r->top == r->bottom || r->left == r->right;
-}
-
-static INLINE int rect_intersects(const SpiceRect* r1, const SpiceRect* r2)
-{
- return r1->left < r2->right && r1->right > r2->left &&
- r1->top < r2->bottom && r1->bottom > r2->top;
-}
-
-static INLINE int rect_is_equal(const SpiceRect *r1, const SpiceRect *r2)
-{
- return r1->top == r2->top && r1->left == r2->left &&
- r1->bottom == r2->bottom && r1->right == r2->right;
-}
-
-static INLINE void rect_union(SpiceRect *dest, const SpiceRect *r)
-{
- dest->top = MIN(dest->top, r->top);
- dest->left = MIN(dest->left, r->left);
- dest->bottom = MAX(dest->bottom, r->bottom);
- dest->right = MAX(dest->right, r->right);
-}
-
-static INLINE int rect_is_same_size(const SpiceRect *r1, const SpiceRect *r2)
-{
- return r1->right - r1->left == r2->right - r2->left &&
- r1->bottom - r1->top == r2->bottom - r2->top;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef __cplusplus
-
-static inline void rect_sect(SpiceRect& r, const SpiceRect& bounds)
-{
- rect_sect(&r, &bounds);
-}
-
-static inline void rect_offset(SpiceRect& r, int dx, int dy)
-{
- rect_offset(&r, dx, dy);
-}
-
-static inline int rect_is_empty(const SpiceRect& r)
-{
- return rect_is_empty(&r);
-}
-
-static inline int rect_intersects(const SpiceRect& r1, const SpiceRect& r2)
-{
- return rect_intersects(&r1, &r2);
-}
-
-static inline int rect_is_equal(const SpiceRect& r1, const SpiceRect& r2)
-{
- return rect_is_equal(&r1, &r2);
-}
-
-static inline void rect_union(SpiceRect& dest, const SpiceRect& r)
-{
- rect_union(&dest, &r);
-}
-
-static inline int rect_is_same_size(const SpiceRect& r1, const SpiceRect& r2)
-{
- return rect_is_same_size(&r1, &r2);
-}
-
-#endif
-
-#endif
diff --git a/common/region.c b/common/region.c
deleted file mode 100644
index 35935ea..0000000
--- a/common/region.c
+++ /dev/null
@@ -1,890 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <spice/macros.h>
-
-#include "region.h"
-#include "rect.h"
-#include "mem.h"
-
-/* true iff two Boxes overlap */
-#define EXTENTCHECK(r1, r2) \
- (!( ((r1)->x2 <= (r2)->x1) || \
- ((r1)->x1 >= (r2)->x2) || \
- ((r1)->y2 <= (r2)->y1) || \
- ((r1)->y1 >= (r2)->y2) ) )
-
-/* true iff Box r1 contains Box r2 */
-#define SUBSUMES(r1, r2) \
- ( ((r1)->x1 <= (r2)->x1) && \
- ((r1)->x2 >= (r2)->x2) && \
- ((r1)->y1 <= (r2)->y1) && \
- ((r1)->y2 >= (r2)->y2) )
-
-
-void region_init(QRegion *rgn)
-{
- pixman_region32_init(rgn);
-}
-
-void region_clear(QRegion *rgn)
-{
- pixman_region32_fini(rgn);
- pixman_region32_init(rgn);
-}
-
-void region_destroy(QRegion *rgn)
-{
- pixman_region32_fini(rgn);
-}
-
-void region_clone(QRegion *dest, const QRegion *src)
-{
- pixman_region32_init(dest);
- pixman_region32_copy(dest, (pixman_region32_t *)src);
-}
-
-#define FIND_BAND(r, r_band_end, r_end, ry1) \
- do { \
- ry1 = r->y1; \
- r_band_end = r + 1; \
- while ((r_band_end != r_end) && (r_band_end->y1 == ry1)) { \
- r_band_end++; \
- } \
- } while (0)
-
-static int test_band(int query,
- int res,
- pixman_box32_t *r1,
- pixman_box32_t *r1_end,
- pixman_box32_t *r2,
- pixman_box32_t *r2_end)
-{
- int x1;
- int x2;
-
- do {
- x1 = MAX(r1->x1, r2->x1);
- x2 = MIN(r1->x2, r2->x2);
-
- /*
- * Is there any overlap between the two rectangles?
- */
- if (x1 < x2) {
- res |= REGION_TEST_SHARED;
-
- if (r1->x1 < r2->x1 || r1->x2 > r2->x2) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- }
-
- if (r2->x1 < r1->x1 || r2->x2 > r1->x2) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
- } else {
- /* No overlap at all, the leftmost is exclusive */
- if (r1->x1 < r2->x1) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- } else {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
- }
-
- if ((res & query) == query) {
- return res;
- }
-
- /*
- * Advance the pointer(s) with the leftmost right side, since the next
- * rectangle on that list may still overlap the other region's
- * current rectangle.
- */
- if (r1->x2 == x2) {
- r1++;
- }
- if (r2->x2 == x2) {
- r2++;
- }
- } while ((r1 != r1_end) && (r2 != r2_end));
-
- /*
- * Deal with whichever band (if any) still has rectangles left.
- */
- if (r1 != r1_end) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- } else if (r2 != r2_end) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
-
- return res;
-}
-
-static int test_generic (pixman_region32_t *reg1,
- pixman_region32_t *reg2,
- int query)
-{
- pixman_box32_t *r1; /* Pointer into first region */
- pixman_box32_t *r2; /* Pointer into 2d region */
- pixman_box32_t *r1_end; /* End of 1st region */
- pixman_box32_t *r2_end; /* End of 2d region */
- int ybot; /* Bottom of intersection */
- int ytop; /* Top of intersection */
- pixman_box32_t * r1_band_end; /* End of current band in r1 */
- pixman_box32_t * r2_band_end; /* End of current band in r2 */
- int top; /* Top of non-overlapping band */
- int bot; /* Bottom of non-overlapping band*/
- int r1y1; /* Temps for r1->y1 and r2->y1 */
- int r2y1;
- int r1_num_rects;
- int r2_num_rects;
- int res;
-
- r1 = pixman_region32_rectangles(reg1, &r1_num_rects);
- r1_end = r1 + r1_num_rects;
-
- r2 = pixman_region32_rectangles(reg2, &r2_num_rects);
- r2_end = r2 + r2_num_rects;
-
- res = 0;
-
- /*
- * Initialize ybot.
- * In the upcoming loop, ybot and ytop serve different functions depending
- * on whether the band being handled is an overlapping or non-overlapping
- * band.
- * In the case of a non-overlapping band (only one of the regions
- * has points in the band), ybot is the bottom of the most recent
- * intersection and thus clips the top of the rectangles in that band.
- * ytop is the top of the next intersection between the two regions and
- * serves to clip the bottom of the rectangles in the current band.
- * For an overlapping band (where the two regions intersect), ytop clips
- * the top of the rectangles of both regions and ybot clips the bottoms.
- */
-
- ybot = MIN(r1->y1, r2->y1);
-
- do {
- /*
- * This algorithm proceeds one source-band (as opposed to a
- * destination band, which is determined by where the two regions
- * intersect) at a time. r1_band_end and r2_band_end serve to mark the
- * rectangle after the last one in the current band for their
- * respective regions.
- */
- FIND_BAND(r1, r1_band_end, r1_end, r1y1);
- FIND_BAND(r2, r2_band_end, r2_end, r2y1);
-
- /*
- * First handle the band that doesn't intersect, if any.
- *
- * Note that attention is restricted to one band in the
- * non-intersecting region at once, so if a region has n
- * bands between the current position and the next place it overlaps
- * the other, this entire loop will be passed through n times.
- */
- if (r1y1 < r2y1) {
- top = MAX (r1y1, ybot);
- bot = MIN (r1->y2, r2y1);
- if (top != bot) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
-
- if ((res & query) == query) {
- return res & query;
- }
- }
-
- ytop = r2y1;
- } else if (r2y1 < r1y1) {
- top = MAX (r2y1, ybot);
- bot = MIN (r2->y2, r1y1);
-
- if (top != bot) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
-
- if ((res & query) == query) {
- return res & query;
- }
- }
- ytop = r1y1;
- } else {
- ytop = r1y1;
- }
-
- /*
- * Now see if we've hit an intersecting band. The two bands only
- * intersect if ybot > ytop
- */
- ybot = MIN (r1->y2, r2->y2);
- if (ybot > ytop) {
- res = test_band(query, res,
- r1, r1_band_end,
- r2, r2_band_end);
- if ((res & query) == query) {
- return res & query;
- }
- }
-
- /*
- * If we've finished with a band (y2 == ybot) we skip forward
- * in the region to the next band.
- */
- if (r1->y2 == ybot) {
- r1 = r1_band_end;
- }
-
- if (r2->y2 == ybot) {
- r2 = r2_band_end;
- }
-
- }
- while (r1 != r1_end && r2 != r2_end);
-
- /*
- * Deal with whichever region (if any) still has rectangles left.
- */
-
- if (r1 != r1_end) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- } else if (r2 != r2_end) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
-
- return res & query;
-}
-
-int region_test(const QRegion *_reg1, const QRegion *_reg2, int query)
-{
- int res;
- pixman_region32_t *reg1 = (pixman_region32_t *)_reg1;
- pixman_region32_t *reg2 = (pixman_region32_t *)_reg2;
-
- query = (query) ? query & REGION_TEST_ALL : REGION_TEST_ALL;
-
- res = 0;
-
- if (!pixman_region32_not_empty(reg1) || !pixman_region32_not_empty(reg2) ||
- !EXTENTCHECK (®1->extents, ®2->extents)) {
- /* One or more regions are empty or they are disjoint */
-
- if (pixman_region32_not_empty(reg1)) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- }
-
- if (pixman_region32_not_empty(reg2)) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
-
- return res & query;
- } else if (!reg1->data && !reg2->data) {
- /* Just two rectangles that intersect */
- res |= REGION_TEST_SHARED;
-
- if (!SUBSUMES(®1->extents, ®2->extents)) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
-
- if (!SUBSUMES(®2->extents, ®1->extents)) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- }
-
- return res & query;
- } else if (!reg2->data && SUBSUMES (®2->extents, ®1->extents)) {
- /* reg2 is just a rect that contains all of reg1 */
-
- res |= REGION_TEST_SHARED; /* some piece must be shared, because reg is not empty */
- res |= REGION_TEST_RIGHT_EXCLUSIVE; /* reg2 contains all of reg1 and then some */
-
- return res & query;
- } else if (!reg1->data && SUBSUMES (®1->extents, ®2->extents)) {
- /* reg1 is just a rect that contains all of reg2 */
-
- res |= REGION_TEST_SHARED; /* some piece must be shared, because reg is not empty */
- res |= REGION_TEST_LEFT_EXCLUSIVE; /* reg1 contains all of reg2 and then some */
-
- return res & query;
- } else if (reg1 == reg2) {
- res |= REGION_TEST_SHARED;
- return res & query;
- } else {
- /* General purpose intersection */
- return test_generic (reg1, reg2, query);
- }
-}
-
-int region_is_valid(const QRegion *rgn)
-{
- return pixman_region32_selfcheck((pixman_region32_t *)rgn);
-}
-
-int region_is_empty(const QRegion *rgn)
-{
- return !pixman_region32_not_empty((pixman_region32_t *)rgn);
-}
-
-SpiceRect *region_dup_rects(const QRegion *rgn, uint32_t *num_rects)
-{
- pixman_box32_t *boxes;
- SpiceRect *rects;
- int n, i;
-
- boxes = pixman_region32_rectangles((pixman_region32_t *)rgn, &n);
- if (num_rects) {
- *num_rects = n;
- }
- rects = spice_new(SpiceRect, n);
- for (i = 0; i < n; i++) {
- rects[i].left = boxes[i].x1;
- rects[i].top = boxes[i].y1;
- rects[i].right = boxes[i].x2;
- rects[i].bottom = boxes[i].y2;
- }
- return rects;
-}
-
-void region_ret_rects(const QRegion *rgn, SpiceRect *rects, uint32_t num_rects)
-{
- pixman_box32_t *boxes;
- unsigned int n, i;
-
- boxes = pixman_region32_rectangles((pixman_region32_t *)rgn, (int *)&n);
- for (i = 0; i < n && i < num_rects; i++) {
- rects[i].left = boxes[i].x1;
- rects[i].top = boxes[i].y1;
- rects[i].right = boxes[i].x2;
- rects[i].bottom = boxes[i].y2;
- }
-
- if (i && i != n) {
- unsigned int x;
-
- for (x = 0; x < (n - num_rects); ++x) {
- rects[i - 1].left = MIN(rects[i - 1].left, boxes[i + x].x1);
- rects[i - 1].top = MIN(rects[i - 1].top, boxes[i + x].y1);
- rects[i - 1].right = MAX(rects[i - 1].right, boxes[i + x].x2);
- rects[i - 1].bottom = MAX(rects[i - 1].bottom, boxes[i + x].y2);
- }
- }
-}
-
-
-int region_is_equal(const QRegion *rgn1, const QRegion *rgn2)
-{
- return pixman_region32_equal((pixman_region32_t *)rgn1, (pixman_region32_t *)rgn2);
-}
-
-int region_intersects(const QRegion *rgn1, const QRegion *rgn2)
-{
- int test_res;
-
- if (!region_bounds_intersects(rgn1, rgn2)) {
- return FALSE;
- }
-
- test_res = region_test(rgn1, rgn2, REGION_TEST_SHARED);
- return !!test_res;
-}
-
-int region_bounds_intersects(const QRegion *rgn1, const QRegion *rgn2)
-{
- pixman_box32_t *extents1, *extents2;
-
- extents1 = pixman_region32_extents((pixman_region32_t *)rgn1);
- extents2 = pixman_region32_extents((pixman_region32_t *)rgn1);
-
- return EXTENTCHECK(extents1, extents2);
-}
-
-int region_contains(const QRegion *rgn, const QRegion *other)
-{
- int test_res;
-
- test_res = region_test(rgn, other, REGION_TEST_RIGHT_EXCLUSIVE);
- return !test_res;
-}
-
-int region_contains_point(const QRegion *rgn, int32_t x, int32_t y)
-{
- return pixman_region32_contains_point((pixman_region32_t *)rgn, x, y, NULL);
-}
-
-void region_or(QRegion *rgn, const QRegion *other_rgn)
-{
- pixman_region32_union(rgn, rgn, (pixman_region32_t *)other_rgn);
-}
-
-void region_and(QRegion *rgn, const QRegion *other_rgn)
-{
- pixman_region32_intersect(rgn, rgn, (pixman_region32_t *)other_rgn);
-}
-
-void region_xor(QRegion *rgn, const QRegion *other_rgn)
-{
- pixman_region32_t intersection;
-
- pixman_region32_copy(&intersection, rgn);
- pixman_region32_intersect(&intersection,
- &intersection,
- (pixman_region32_t *)other_rgn);
- pixman_region32_union(rgn, rgn, (pixman_region32_t *)other_rgn);
- pixman_region32_subtract(rgn, rgn, &intersection);
- pixman_region32_fini(&intersection);
-}
-
-void region_exclude(QRegion *rgn, const QRegion *other_rgn)
-{
- pixman_region32_subtract(rgn, rgn, (pixman_region32_t *)other_rgn);
-}
-
-void region_add(QRegion *rgn, const SpiceRect *r)
-{
- pixman_region32_union_rect(rgn, rgn, r->left, r->top,
- r->right - r->left,
- r->bottom - r->top);
-}
-
-void region_remove(QRegion *rgn, const SpiceRect *r)
-{
- pixman_region32_t rg;
-
- pixman_region32_init_rect(&rg, r->left, r->top,
- r->right - r->left,
- r->bottom - r->top);
- pixman_region32_subtract(rgn, rgn, &rg);
- pixman_region32_fini(&rg);
-}
-
-
-void region_offset(QRegion *rgn, int32_t dx, int32_t dy)
-{
- pixman_region32_translate(rgn, dx, dy);
-}
-
-void region_dump(const QRegion *rgn, const char *prefix)
-{
- pixman_box32_t *rects, *extents;
- int n_rects, i;
-
- printf("%sREGION: %p, ", prefix, rgn);
-
- if (!pixman_region32_not_empty((pixman_region32_t *)rgn)) {
- printf("EMPTY\n");
- return;
- }
-
- extents = pixman_region32_extents((pixman_region32_t *)rgn);
- rects = pixman_region32_rectangles((pixman_region32_t *)rgn, &n_rects);
- printf("num %u bounds (%d, %d, %d, %d)\n",
- n_rects,
- extents->x1,
- extents->y1,
- extents->x2,
- extents->y2);
-
-
- for (i = 0; i < n_rects; i++) {
- printf("%*s %12d %12d %12d %12d\n",
- (int)strlen(prefix), "",
- rects[i].x1,
- rects[i].y1,
- rects[i].x2,
- rects[i].y2);
- }
-}
-
-#ifdef REGION_TEST
-
-static int slow_region_test(const QRegion *rgn, const QRegion *other_rgn, int query)
-{
- pixman_region32_t intersection;
- int res;
-
- pixman_region32_init(&intersection);
- pixman_region32_intersect(&intersection,
- (pixman_region32_t *)rgn,
- (pixman_region32_t *)other_rgn);
-
- res = 0;
-
- if (query & REGION_TEST_SHARED &&
- pixman_region32_not_empty(&intersection)) {
- res |= REGION_TEST_SHARED;
- }
-
- if (query & REGION_TEST_LEFT_EXCLUSIVE &&
- !pixman_region32_equal(&intersection, (pixman_region32_t *)rgn)) {
- res |= REGION_TEST_LEFT_EXCLUSIVE;
- }
-
- if (query & REGION_TEST_RIGHT_EXCLUSIVE &&
- !pixman_region32_equal(&intersection, (pixman_region32_t *)other_rgn)) {
- res |= REGION_TEST_RIGHT_EXCLUSIVE;
- }
-
- pixman_region32_fini(&intersection);
-
- return res;
-}
-
-
-static int rect_is_valid(const SpiceRect *r)
-{
- if (r->top > r->bottom || r->left > r->right) {
- printf("%s: invalid rect\n", __FUNCTION__);
- return FALSE;
- }
- return TRUE;
-}
-
-static void rect_set(SpiceRect *r, int32_t top, int32_t left, int32_t bottom, int32_t right)
-{
- r->top = top;
- r->left = left;
- r->bottom = bottom;
- r->right = right;
- ASSERT(rect_is_valid(r));
-}
-
-static void random_region(QRegion *reg)
-{
- int i;
- int num_rects;
- int x, y, w, h;
- SpiceRect _r;
- SpiceRect *r = &_r;
-
- region_clear(reg);
-
- num_rects = rand() % 20;
- for (i = 0; i < num_rects; i++) {
- x = rand()%100;
- y = rand()%100;
- w = rand()%100;
- h = rand()%100;
- rect_set(r,
- x, y,
- x+w, y+h);
- region_add(reg, r);
- }
-}
-
-static void test(const QRegion *r1, const QRegion *r2, int *expected)
-{
- printf("r1 is_empty %s [%s]\n",
- region_is_empty(r1) ? "TRUE" : "FALSE",
- (region_is_empty(r1) == *(expected++)) ? "OK" : "ERR");
- printf("r2 is_empty %s [%s]\n",
- region_is_empty(r2) ? "TRUE" : "FALSE",
- (region_is_empty(r2) == *(expected++)) ? "OK" : "ERR");
- printf("is_equal %s [%s]\n",
- region_is_equal(r1, r2) ? "TRUE" : "FALSE",
- (region_is_equal(r1, r2) == *(expected++)) ? "OK" : "ERR");
- printf("intersects %s [%s]\n",
- region_intersects(r1, r2) ? "TRUE" : "FALSE",
- (region_intersects(r1, r2) == *(expected++)) ? "OK" : "ERR");
- printf("contains %s [%s]\n",
- region_contains(r1, r2) ? "TRUE" : "FALSE",
- (region_contains(r1, r2) == *(expected++)) ? "OK" : "ERR");
-}
-
-enum {
- EXPECT_R1_EMPTY,
- EXPECT_R2_EMPTY,
- EXPECT_EQUAL,
- EXPECT_SECT,
- EXPECT_CONT,
-};
-
-int main(void)
-{
- QRegion _r1, _r2, _r3;
- QRegion *r1 = &_r1;
- QRegion *r2 = &_r2;
- QRegion *r3 = &_r3;
- SpiceRect _r;
- SpiceRect *r = &_r;
- int expected[5];
- int i, j;
-
- region_init(r1);
- region_init(r2);
-
- printf("dump r1 empty rgn [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = TRUE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = TRUE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clone(r3, r1);
- printf("dump r3 clone rgn [%s]\n", region_is_valid(r3) ? "VALID" : "INVALID");
- region_dump(r3, "");
- expected[EXPECT_R1_EMPTY] = TRUE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = TRUE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r3, expected);
- region_destroy(r3);
- printf("\n");
-
- rect_set(r, 0, 0, 100, 100);
- region_add(r1, r);
- printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r1);
- rect_set(r, 0, 0, 0, 0);
- region_add(r1, r);
- printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = TRUE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = TRUE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- rect_set(r, -100, -100, 0, 0);
- region_add(r1, r);
- printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r1);
- rect_set(r, -100, -100, 100, 100);
- region_add(r1, r);
- printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
-
- region_clear(r1);
- region_clear(r2);
-
- rect_set(r, 100, 100, 200, 200);
- region_add(r1, r);
- printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- rect_set(r, 300, 300, 400, 400);
- region_add(r1, r);
- printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
- region_dump(r1, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = TRUE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- rect_set(r, 500, 500, 600, 600);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = FALSE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r2);
-
- rect_set(r, 100, 100, 200, 200);
- region_add(r2, r);
- rect_set(r, 300, 300, 400, 400);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = TRUE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r2);
-
- rect_set(r, 100, 100, 200, 200);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r2);
-
- rect_set(r, -2000, -2000, -1000, -1000);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = FALSE;
- expected[EXPECT_CONT] = FALSE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r2);
-
- rect_set(r, -2000, -2000, 1000, 1000);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = FALSE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r2);
-
- rect_set(r, 150, 150, 175, 175);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r2, expected);
- printf("\n");
-
- region_clear(r2);
-
- rect_set(r, 150, 150, 350, 350);
- region_add(r2, r);
- printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = FALSE;
- test(r1, r2, expected);
- printf("\n");
-
- region_and(r2, r1);
- printf("dump r2 and r1 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
- region_dump(r2, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = FALSE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = FALSE;
- test(r2, r1, expected);
- printf("\n");
-
-
- region_clone(r3, r1);
- printf("dump r3 clone rgn [%s]\n", region_is_valid(r3) ? "VALID" : "INVALID");
- region_dump(r3, "");
- expected[EXPECT_R1_EMPTY] = FALSE;
- expected[EXPECT_R2_EMPTY] = FALSE;
- expected[EXPECT_EQUAL] = TRUE;
- expected[EXPECT_SECT] = TRUE;
- expected[EXPECT_CONT] = TRUE;
- test(r1, r3, expected);
- printf("\n");
-
- j = 0;
- for (i = 0; i < 1000000; i++) {
- int res1, res2, test;
- int tests[] = {
- REGION_TEST_LEFT_EXCLUSIVE,
- REGION_TEST_RIGHT_EXCLUSIVE,
- REGION_TEST_SHARED,
- REGION_TEST_LEFT_EXCLUSIVE | REGION_TEST_RIGHT_EXCLUSIVE,
- REGION_TEST_LEFT_EXCLUSIVE | REGION_TEST_SHARED,
- REGION_TEST_RIGHT_EXCLUSIVE | REGION_TEST_SHARED,
- REGION_TEST_LEFT_EXCLUSIVE | REGION_TEST_RIGHT_EXCLUSIVE | REGION_TEST_SHARED
- };
-
- random_region(r1);
- random_region(r2);
-
- for (test = 0; test < 7; test++) {
- res1 = region_test(r1, r2, tests[test]);
- res2 = slow_region_test(r1, r2, tests[test]);
- if (res1 != res2) {
- printf ("Error in region_test %d, got %d, expected %d, query=%d\n",
- j, res1, res2, tests[test]);
- printf ("r1:\n");
- region_dump(r1, "");
- printf ("r2:\n");
- region_dump(r2, "");
- }
- j++;
- }
- }
-
- region_destroy(r3);
- region_destroy(r1);
- region_destroy(r2);
-
- return 0;
-}
-
-#endif
diff --git a/common/region.h b/common/region.h
deleted file mode 100644
index 954e06f..0000000
--- a/common/region.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_REGION
-#define _H_REGION
-
-#include <stdint.h>
-#include "draw.h"
-#include <pixman_utils.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef pixman_region32_t QRegion;
-
-#define REGION_TEST_LEFT_EXCLUSIVE (1 << 0)
-#define REGION_TEST_RIGHT_EXCLUSIVE (1 << 1)
-#define REGION_TEST_SHARED (1 << 2)
-#define REGION_TEST_ALL \
- (REGION_TEST_LEFT_EXCLUSIVE | REGION_TEST_RIGHT_EXCLUSIVE | REGION_TEST_SHARED)
-
-void region_init(QRegion *rgn);
-void region_clear(QRegion *rgn);
-void region_destroy(QRegion *rgn);
-void region_clone(QRegion *dest, const QRegion *src);
-SpiceRect *region_dup_rects(const QRegion *rgn, uint32_t *num_rects);
-void region_ret_rects(const QRegion *rgn, SpiceRect *rects, uint32_t num_rects);
-
-int region_test(const QRegion *rgn, const QRegion *other_rgn, int query);
-int region_is_valid(const QRegion *rgn);
-int region_is_empty(const QRegion *rgn);
-int region_is_equal(const QRegion *rgn1, const QRegion *rgn2);
-int region_intersects(const QRegion *rgn1, const QRegion *rgn2);
-int region_bounds_intersects(const QRegion *rgn1, const QRegion *rgn2);
-int region_contains(const QRegion *rgn, const QRegion *other);
-int region_contains_point(const QRegion *rgn, int32_t x, int32_t y);
-
-void region_or(QRegion *rgn, const QRegion *other_rgn);
-void region_and(QRegion *rgn, const QRegion *other_rgn);
-void region_xor(QRegion *rgn, const QRegion *other_rgn);
-void region_exclude(QRegion *rgn, const QRegion *other_rgn);
-
-void region_add(QRegion *rgn, const SpiceRect *r);
-void region_remove(QRegion *rgn, const SpiceRect *r);
-
-void region_offset(QRegion *rgn, int32_t dx, int32_t dy);
-
-void region_dump(const QRegion *rgn, const char *prefix);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/ring.h b/common/ring.h
deleted file mode 100644
index cb70696..0000000
--- a/common/ring.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_RING2
-#define _H_RING2
-
-#include "spice_common.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct Ring RingItem;
-typedef struct Ring {
- RingItem *prev;
- RingItem *next;
-} Ring;
-
-static inline void ring_init(Ring *ring)
-{
- ring->next = ring->prev = ring;
-}
-
-static inline void ring_item_init(RingItem *item)
-{
- item->next = item->prev = NULL;
-}
-
-static inline int ring_item_is_linked(RingItem *item)
-{
- return !!item->next;
-}
-
-static inline int ring_is_empty(Ring *ring)
-{
- ASSERT(ring->next != NULL && ring->prev != NULL);
- return ring == ring->next;
-}
-
-static inline void ring_add(Ring *ring, RingItem *item)
-{
- ASSERT(ring->next != NULL && ring->prev != NULL);
- ASSERT(item->next == NULL && item->prev == NULL);
-
- item->next = ring->next;
- item->prev = ring;
- ring->next = item->next->prev = item;
-}
-
-static inline void ring_add_after(RingItem *item, RingItem *pos)
-{
- ring_add(pos, item);
-}
-
-static inline void ring_add_before(RingItem *item, RingItem *pos)
-{
- ring_add(pos->prev, item);
-}
-
-static inline void __ring_remove(RingItem *item)
-{
- item->next->prev = item->prev;
- item->prev->next = item->next;
- item->prev = item->next = 0;
-}
-
-static inline void ring_remove(RingItem *item)
-{
- ASSERT(item->next != NULL && item->prev != NULL);
- ASSERT(item->next != item);
-
- __ring_remove(item);
-}
-
-static inline RingItem *ring_get_head(Ring *ring)
-{
- RingItem *ret;
-
- ASSERT(ring->next != NULL && ring->prev != NULL);
-
- if (ring_is_empty(ring)) {
- return NULL;
- }
- ret = ring->next;
- return ret;
-}
-
-static inline RingItem *ring_get_tail(Ring *ring)
-{
- RingItem *ret;
-
- ASSERT(ring->next != NULL && ring->prev != NULL);
-
- if (ring_is_empty(ring)) {
- return NULL;
- }
- ret = ring->prev;
- return ret;
-}
-
-static inline RingItem *ring_next(Ring *ring, RingItem *pos)
-{
- RingItem *ret;
-
- ASSERT(ring->next != NULL && ring->prev != NULL);
- ASSERT(pos);
- ASSERT(pos->next != NULL && pos->prev != NULL);
- ret = pos->next;
- return (ret == ring) ? NULL : ret;
-}
-
-static inline RingItem *ring_prev(Ring *ring, RingItem *pos)
-{
- RingItem *ret;
-
- ASSERT(ring->next != NULL && ring->prev != NULL);
- ASSERT(pos);
- ASSERT(pos->next != NULL && pos->prev != NULL);
- ret = pos->prev;
- return (ret == ring) ? NULL : ret;
-}
-
-#define RING_FOREACH_SAFE(var, next, ring) \
- for ((var) = ring_get_head(ring); \
- (var) && ((next) = ring_next(ring, (var)), 1); \
- (var) = (next))
-
-
-#define RING_FOREACH(var, ring) \
- for ((var) = ring_get_head(ring); \
- (var); \
- (var) = ring_next(ring, var))
-
-#define RING_FOREACH_REVERSED(var, ring) \
- for ((var) = ring_get_tail(ring); \
- (var); \
- (var) = ring_prev(ring, var))
-
-
-static inline unsigned int ring_get_length(Ring *ring)
-{
- RingItem *i;
- unsigned int ret = 0;
-
- for (i = ring_get_head(ring);
- i != NULL;
- i = ring_next(ring, i))
- ret++;
-
- return ret;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/rop3.c b/common/rop3.c
deleted file mode 100644
index 12d9f11..0000000
--- a/common/rop3.c
+++ /dev/null
@@ -1,650 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-
-#include "rop3.h"
-#include "spice_common.h"
-
-typedef void (*rop3_with_pattern_handler_t)(pixman_image_t *d, pixman_image_t *s,
- SpicePoint *src_pos, pixman_image_t *p,
- SpicePoint *pat_pos);
-
-typedef void (*rop3_with_color_handler_t)(pixman_image_t *d, pixman_image_t *s,
- SpicePoint *src_pos, uint32_t rgb);
-
-typedef void (*rop3_test_handler_t)(void);
-
-#define ROP3_NUM_OPS 256
-
-static rop3_with_pattern_handler_t rop3_with_pattern_handlers_32[ROP3_NUM_OPS];
-static rop3_with_pattern_handler_t rop3_with_pattern_handlers_16[ROP3_NUM_OPS];
-static rop3_with_color_handler_t rop3_with_color_handlers_32[ROP3_NUM_OPS];
-static rop3_with_color_handler_t rop3_with_color_handlers_16[ROP3_NUM_OPS];
-static rop3_test_handler_t rop3_test_handlers_32[ROP3_NUM_OPS];
-static rop3_test_handler_t rop3_test_handlers_16[ROP3_NUM_OPS];
-
-
-static void default_rop3_with_pattern_handler(pixman_image_t *d, pixman_image_t *s,
- SpicePoint *src_pos, pixman_image_t *p,
- SpicePoint *pat_pos)
-{
- WARN("not implemented");
-}
-
-static void default_rop3_withe_color_handler(pixman_image_t *d, pixman_image_t *s, SpicePoint *src_pos,
- uint32_t rgb)
-{
- WARN("not implemented");
-}
-
-static void default_rop3_test_handler(void)
-{
-}
-
-#define ROP3_HANDLERS_DEPTH(name, formula, index, depth) \
-static void rop3_handle_p##depth##_##name(pixman_image_t *d, pixman_image_t *s, \
- SpicePoint *src_pos, \
- pixman_image_t *p, SpicePoint *pat_pos) \
-{ \
- int width = pixman_image_get_width(d); \
- int height = pixman_image_get_height(d); \
- uint8_t *dest_line = (uint8_t *)pixman_image_get_data(d); \
- int dest_stride = pixman_image_get_stride(d); \
- uint8_t *end_line = dest_line + height * dest_stride; \
- \
- int pat_width = pixman_image_get_width(p); \
- int pat_height = pixman_image_get_height(p); \
- uint8_t *pat_base = (uint8_t *)pixman_image_get_data(p); \
- int pat_stride = pixman_image_get_stride(p); \
- int pat_v_offset = pat_pos->y; \
- \
- int src_stride = pixman_image_get_stride(s); \
- uint8_t *src_line; \
- src_line = (uint8_t *)pixman_image_get_data(s) + src_pos->y * src_stride + (src_pos->x * depth / 8); \
- \
- for (; dest_line < end_line; dest_line += dest_stride, src_line += src_stride) { \
- uint##depth##_t *dest = (uint##depth##_t *)dest_line; \
- uint##depth##_t *end = dest + width; \
- uint##depth##_t *src = (uint##depth##_t *)src_line; \
- \
- int pat_h_offset = pat_pos->x; \
- \
- for (; dest < end; dest++, src++) { \
- uint##depth##_t *pat; \
- pat = (uint##depth##_t *) \
- (pat_base + pat_v_offset * pat_stride + (pat_h_offset * depth / 8)); \
- *dest = formula; \
- pat_h_offset = (pat_h_offset + 1) % pat_width; \
- } \
- \
- pat_v_offset = (pat_v_offset + 1) % pat_height; \
- } \
-} \
- \
-static void rop3_handle_c##depth##_##name(pixman_image_t *d, pixman_image_t *s, \
- SpicePoint *src_pos, \
- uint32_t rgb) \
-{ \
- int width = pixman_image_get_width(d); \
- int height = pixman_image_get_height(d); \
- uint8_t *dest_line = (uint8_t *)pixman_image_get_data(d); \
- int dest_stride = pixman_image_get_stride(d); \
- uint8_t *end_line = dest_line + height * dest_stride; \
- uint##depth##_t _pat = rgb; \
- uint##depth##_t *pat = &_pat; \
- \
- int src_stride = pixman_image_get_stride(s); \
- uint8_t *src_line; \
- src_line = (uint8_t *) \
- pixman_image_get_data(s) + src_pos->y * src_stride + (src_pos->x * depth / 8); \
- \
- for (; dest_line < end_line; dest_line += dest_stride, src_line += src_stride) { \
- uint##depth##_t *dest = (uint##depth##_t *)dest_line; \
- uint##depth##_t *end = dest + width; \
- uint##depth##_t *src = (uint##depth##_t *)src_line; \
- for (; dest < end; dest++, src++) { \
- *dest = formula; \
- } \
- } \
-} \
- \
-static void rop3_test##depth##_##name(void) \
-{ \
- uint8_t d = 0xaa; \
- uint8_t s = 0xcc; \
- uint8_t p = 0xf0; \
- uint8_t *pat = &p; \
- uint8_t *src = &s; \
- uint8_t *dest = &d; \
- \
- d = formula; \
- if (d != index) { \
- printf("%s: failed, result is 0x%x expect 0x%x\n", __FUNCTION__, d, index); \
- } \
-}
-
-#define ROP3_HANDLERS(name, formula, index) \
- ROP3_HANDLERS_DEPTH(name, formula, index, 32) \
- ROP3_HANDLERS_DEPTH(name, formula, index, 16)
-
-ROP3_HANDLERS(DPSoon, ~(*pat | *src | *dest), 0x01);
-ROP3_HANDLERS(DPSona, ~(*pat | *src) & *dest, 0x02);
-ROP3_HANDLERS(SDPona, ~(*pat | *dest) & *src, 0x04);
-ROP3_HANDLERS(PDSxnon, ~(~(*src ^ *dest) | *pat), 0x06);
-ROP3_HANDLERS(PDSaon, ~((*src & *dest) | *pat), 0x07);
-ROP3_HANDLERS(SDPnaa, ~*pat & *dest & *src, 0x08);
-ROP3_HANDLERS(PDSxon, ~((*src ^ *dest) | *pat), 0x09);
-ROP3_HANDLERS(PSDnaon, ~((~*dest & *src) | *pat), 0x0b);
-ROP3_HANDLERS(PDSnaon, ~((~*src & *dest) | *pat), 0x0d);
-ROP3_HANDLERS(PDSonon, ~(~(*src | *dest) | *pat), 0x0e);
-ROP3_HANDLERS(PDSona, ~(*src | *dest) & *pat, 0x10);
-ROP3_HANDLERS(SDPxnon, ~(~(*pat ^ *dest) | *src), 0x12);
-ROP3_HANDLERS(SDPaon, ~((*pat & *dest) | *src), 0x13);
-ROP3_HANDLERS(DPSxnon, ~(~(*pat ^ *src) | *dest), 0x14);
-ROP3_HANDLERS(DPSaon, ~((*pat & *src) | *dest), 0x15);
-ROP3_HANDLERS(PSDPSanaxx, (~(*pat & *src) & *dest) ^ *src ^ *pat, 0x16);
-ROP3_HANDLERS(SSPxDSxaxn, ~(((*src ^ *dest) & (*src ^ *pat)) ^ *src), 0x17);
-ROP3_HANDLERS(SPxPDxa, (*src ^ *pat) & (*pat ^ *dest), 0x18);
-ROP3_HANDLERS(SDPSanaxn, ~((~(*pat & *src) & *dest) ^ *src), 0x19);
-ROP3_HANDLERS(PDSPaox, ((*pat & *src) | *dest) ^ *pat, 0x1a);
-ROP3_HANDLERS(SDPSxaxn, ~(((*pat ^ *src) & *dest) ^ *src), 0x1b);
-ROP3_HANDLERS(PSDPaox, ((*pat & *dest) | *src) ^ *pat, 0x1c);
-ROP3_HANDLERS(DSPDxaxn, ~(((*pat ^ *dest) & *src) ^ *dest), 0x1d);
-ROP3_HANDLERS(PDSox, (*dest | *src) ^ *pat, 0x1e);
-ROP3_HANDLERS(PDSoan, ~((*src | *dest) & *pat), 0x1f);
-ROP3_HANDLERS(DPSnaa, ~*src & *pat & *dest, 0x20);
-ROP3_HANDLERS(SDPxon, ~((*pat ^ *dest) | *src), 0x21);
-ROP3_HANDLERS(SPDnaon, ~((~*dest & *pat) | *src), 0x23);
-ROP3_HANDLERS(SPxDSxa, (*src ^ *pat) & (*dest ^ *src), 0x24);
-ROP3_HANDLERS(PDSPanaxn, ~((~(*src & *pat) & *dest) ^ *pat), 0x25);
-ROP3_HANDLERS(SDPSaox, ((*src & *pat) | *dest) ^ *src, 0x26);
-ROP3_HANDLERS(SDPSxnox, (~(*src ^ *pat) | *dest) ^ *src, 0x27);
-ROP3_HANDLERS(DPSxa, (*pat ^ *src) & *dest, 0x28);
-ROP3_HANDLERS(PSDPSaoxxn, ~(((*src & *pat) | *dest) ^ *src ^ *pat), 0x29);
-ROP3_HANDLERS(DPSana, ~(*src & *pat) & *dest, 0x2a);
-ROP3_HANDLERS(SSPxPDxaxn, ~(((*pat ^ *dest) & (*src ^ *pat)) ^ *src), 0x2b);
-ROP3_HANDLERS(SPDSoax, ((*src | *dest) & *pat) ^ *src, 0x2c);
-ROP3_HANDLERS(PSDnox, (~*dest | *src) ^ *pat, 0x2d);
-ROP3_HANDLERS(PSDPxox, ((*pat ^ *dest) | *src) ^ *pat, 0x2e);
-ROP3_HANDLERS(PSDnoan, ~((~*dest | *src) & *pat), 0x2f);
-ROP3_HANDLERS(SDPnaon, ~((~*pat & *dest) | *src), 0x31);
-ROP3_HANDLERS(SDPSoox, (*src | *pat | *dest) ^ *src, 0x32);
-ROP3_HANDLERS(SPDSaox, ((*src & *dest) | *pat) ^ *src, 0x34);
-ROP3_HANDLERS(SPDSxnox, (~(*src ^ *dest) | *pat) ^ *src, 0x35);
-ROP3_HANDLERS(SDPox, (*pat | *dest) ^ *src, 0x36);
-ROP3_HANDLERS(SDPoan, ~((*pat | *dest) & *src), 0x37);
-ROP3_HANDLERS(PSDPoax, ((*pat | *dest) & *src) ^ *pat, 0x38);
-ROP3_HANDLERS(SPDnox, (~*dest | *pat) ^ *src, 0x39);
-ROP3_HANDLERS(SPDSxox, ((*src ^ *dest) | *pat) ^ *src, 0x3a);
-ROP3_HANDLERS(SPDnoan, ~((~*dest | *pat) & *src), 0x3b);
-ROP3_HANDLERS(SPDSonox, (~(*src | *dest) | *pat) ^ *src, 0x3d);
-ROP3_HANDLERS(SPDSnaox, ((~*src & *dest) | *pat) ^ *src, 0x3e);
-ROP3_HANDLERS(PSDnaa, ~*dest & *src & *pat, 0x40);
-ROP3_HANDLERS(DPSxon, ~((*src ^ *pat) | *dest), 0x41);
-ROP3_HANDLERS(SDxPDxa, (*src ^ *dest) & (*pat ^ *dest), 0x42);
-ROP3_HANDLERS(SPDSanaxn, ~((~(*src & *dest) & *pat) ^ *src), 0x43);
-ROP3_HANDLERS(DPSnaon, ~((~*src & *pat) | *dest), 0x45);
-ROP3_HANDLERS(DSPDaox, ((*dest & *pat) | *src) ^ *dest, 0x46);
-ROP3_HANDLERS(PSDPxaxn, ~(((*pat ^ *dest) & *src) ^ *pat), 0x47);
-ROP3_HANDLERS(SDPxa, (*pat ^ *dest) & *src, 0x48);
-ROP3_HANDLERS(PDSPDaoxxn, ~(((*dest & *pat) | *src) ^ *dest ^ *pat), 0x49);
-ROP3_HANDLERS(DPSDoax, ((*dest | *src) & *pat) ^ *dest, 0x4a);
-ROP3_HANDLERS(PDSnox, (~*src | *dest) ^ *pat, 0x4b);
-ROP3_HANDLERS(SDPana, ~(*pat & *dest) & *src, 0x4c);
-ROP3_HANDLERS(SSPxDSxoxn, ~(((*src ^ *dest) | (*src ^ *pat)) ^ *src), 0x4d);
-ROP3_HANDLERS(PDSPxox, ((*pat ^ *src) | *dest) ^ *pat, 0x4e);
-ROP3_HANDLERS(PDSnoan, ~((~*src | *dest) & *pat), 0x4f);
-ROP3_HANDLERS(DSPnaon, ~((~*pat & *src) | *dest), 0x51);
-ROP3_HANDLERS(DPSDaox, ((*dest & *src) | *pat) ^ *dest, 0x52);
-ROP3_HANDLERS(SPDSxaxn, ~(((*src ^ *dest) & *pat) ^ *src), 0x53);
-ROP3_HANDLERS(DPSonon, ~(~(*src | *pat) | *dest), 0x54);
-ROP3_HANDLERS(DPSox, (*src | *pat) ^ *dest, 0x56);
-ROP3_HANDLERS(DPSoan, ~((*src | *pat) & *dest), 0x57);
-ROP3_HANDLERS(PDSPoax, ((*pat | *src) & *dest) ^ *pat, 0x58);
-ROP3_HANDLERS(DPSnox, (~*src | *pat) ^ *dest, 0x59);
-ROP3_HANDLERS(DPSDonox, (~(*dest | *src) | *pat) ^ *dest, 0x5b);
-ROP3_HANDLERS(DPSDxox, ((*dest ^ *src) | *pat) ^ *dest, 0x5c);
-ROP3_HANDLERS(DPSnoan, ~((~*src | *pat) & *dest), 0x5d);
-ROP3_HANDLERS(DPSDnaox, ((~*dest & *src) | *pat) ^ *dest, 0x5e);
-ROP3_HANDLERS(PDSxa, (*src ^ *dest) & *pat, 0x60);
-ROP3_HANDLERS(DSPDSaoxxn, ~(((*src & *dest) | *pat) ^ *src ^ *dest), 0x61);
-ROP3_HANDLERS(DSPDoax, ((*dest | *pat) & *src) ^ *dest, 0x62);
-ROP3_HANDLERS(SDPnox, (~*pat | *dest) ^ *src, 0x63);
-ROP3_HANDLERS(SDPSoax, ((*src | *pat) & *dest) ^ *src, 0x64);
-ROP3_HANDLERS(DSPnox, (~*pat | *src) ^ *dest, 0x65);
-ROP3_HANDLERS(SDPSonox, (~(*src | *pat) | *dest) ^ *src, 0x67);
-ROP3_HANDLERS(DSPDSonoxxn, ~((~(*src | *dest) | *pat) ^ *src ^ *dest), 0x68);
-ROP3_HANDLERS(PDSxxn, ~(*src ^ *dest ^ *pat), 0x69);
-ROP3_HANDLERS(DPSax, (*src & *pat) ^ *dest, 0x6a);
-ROP3_HANDLERS(PSDPSoaxxn, ~(((*src | *pat) & *dest) ^ *src ^ *pat), 0x6b);
-ROP3_HANDLERS(SDPax, (*pat & *dest) ^ *src, 0x6c);
-ROP3_HANDLERS(PDSPDoaxxn, ~(((*dest | *pat) & *src) ^ *dest ^ *pat), 0x6d);
-ROP3_HANDLERS(SDPSnoax, ((~*src | *pat) & *dest) ^ *src, 0x6e);
-ROP3_HANDLERS(PDSxnan, ~(~(*src ^ *dest) & *pat), 0x6f);
-ROP3_HANDLERS(PDSana, ~(*src & *dest) & *pat, 0x70);
-ROP3_HANDLERS(SSDxPDxaxn, ~(((*dest ^ *pat) & (*src ^ *dest)) ^ *src), 0x71);
-ROP3_HANDLERS(SDPSxox, ((*src ^ *pat) | *dest) ^ *src, 0x72);
-ROP3_HANDLERS(SDPnoan, ~((~*pat | *dest) & *src), 0x73);
-ROP3_HANDLERS(DSPDxox, ((*dest ^ *pat) | *src) ^ *dest, 0x74);
-ROP3_HANDLERS(DSPnoan, ~((~*pat | *src) & *dest), 0x75);
-ROP3_HANDLERS(SDPSnaox, ((~*src & *pat) | *dest) ^ *src, 0x76);
-ROP3_HANDLERS(PDSax, (*src & *dest) ^ *pat, 0x78);
-ROP3_HANDLERS(DSPDSoaxxn, ~(((*src | *dest) & *pat) ^ *src ^ *dest), 0x79);
-ROP3_HANDLERS(DPSDnoax, ((~*dest | *src) & *pat) ^ *dest, 0x7a);
-ROP3_HANDLERS(SDPxnan, ~(~(*pat ^ *dest) & *src), 0x7b);
-ROP3_HANDLERS(SPDSnoax, ((~*src | *dest) & *pat) ^ *src, 0x7c);
-ROP3_HANDLERS(DPSxnan, ~(~(*src ^ *pat) & *dest), 0x7d);
-ROP3_HANDLERS(SPxDSxo, (*src ^ *dest) | (*pat ^ *src), 0x7e);
-ROP3_HANDLERS(DPSaan, ~(*src & *pat & *dest), 0x7f);
-ROP3_HANDLERS(DPSaa, *src & *pat & *dest, 0x80);
-ROP3_HANDLERS(SPxDSxon, ~((*src ^ *dest) | (*pat ^ *src)), 0x81);
-ROP3_HANDLERS(DPSxna, ~(*src ^ *pat) & *dest, 0x82);
-ROP3_HANDLERS(SPDSnoaxn, ~(((~*src | *dest) & *pat) ^ *src), 0x83);
-ROP3_HANDLERS(SDPxna, ~(*pat ^ *dest) & *src, 0x84);
-ROP3_HANDLERS(PDSPnoaxn, ~(((~*pat | *src) & *dest) ^ *pat), 0x85);
-ROP3_HANDLERS(DSPDSoaxx, ((*src | *dest) & *pat) ^ *src ^ *dest, 0x86);
-ROP3_HANDLERS(PDSaxn, ~((*src & *dest) ^ *pat), 0x87);
-ROP3_HANDLERS(SDPSnaoxn, ~(((~*src & *pat) | *dest) ^ *src), 0x89);
-ROP3_HANDLERS(DSPnoa, (~*pat | *src) & *dest, 0x8a);
-ROP3_HANDLERS(DSPDxoxn, ~(((*dest ^ *pat) | *src) ^ *dest), 0x8b);
-ROP3_HANDLERS(SDPnoa, (~*pat | *dest) & *src, 0x8c);
-ROP3_HANDLERS(SDPSxoxn, ~(((*src ^ *pat) | *dest) ^ *src), 0x8d);
-ROP3_HANDLERS(SSDxPDxax, ((*dest ^ *pat) & (*dest ^ *src)) ^ *src, 0x8e);
-ROP3_HANDLERS(PDSanan, ~(~(*src & *dest) & *pat), 0x8f);
-ROP3_HANDLERS(PDSxna, ~(*src ^ *dest) & *pat, 0x90);
-ROP3_HANDLERS(SDPSnoaxn, ~(((~*src | *pat) & *dest) ^ *src), 0x91);
-ROP3_HANDLERS(DPSDPoaxx, ((*pat | *dest) & *src) ^ *pat ^ *dest, 0x92);
-ROP3_HANDLERS(SPDaxn, ~((*dest & *pat) ^ *src), 0x93);
-ROP3_HANDLERS(PSDPSoaxx, ((*src | *pat) & *dest) ^ *src ^ *pat, 0x94);
-ROP3_HANDLERS(DPSaxn, ~((*src & *pat) ^ *dest), 0x95);
-ROP3_HANDLERS(DPSxx, *src ^ *pat ^ *dest, 0x96);
-ROP3_HANDLERS(PSDPSonoxx, (~(*src | *pat) | *dest) ^ *src ^ *pat, 0x97);
-ROP3_HANDLERS(SDPSonoxn, ~((~(*src | *pat) | *dest) ^ *src), 0x98);
-ROP3_HANDLERS(DPSnax, (~*src & *pat) ^ *dest, 0x9a);
-ROP3_HANDLERS(SDPSoaxn, ~(((*src | *pat) & *dest) ^ *src), 0x9b);
-ROP3_HANDLERS(SPDnax, (~*dest & *pat) ^ *src, 0x9c);
-ROP3_HANDLERS(DSPDoaxn, ~(((*dest | *pat) & *src) ^ *dest), 0x9d);
-ROP3_HANDLERS(DSPDSaoxx, ((*src & *dest) | *pat) ^ *src ^ *dest, 0x9e);
-ROP3_HANDLERS(PDSxan, ~((*src ^ *dest) & *pat), 0x9f);
-ROP3_HANDLERS(PDSPnaoxn, ~(((~*pat & *src) | *dest) ^ *pat), 0xa1);
-ROP3_HANDLERS(DPSnoa, (~*src | *pat) & *dest, 0xa2);
-ROP3_HANDLERS(DPSDxoxn, ~(((*dest ^ *src) | *pat) ^ *dest), 0xa3);
-ROP3_HANDLERS(PDSPonoxn, ~((~(*pat | *src) | *dest) ^ *pat), 0xa4);
-ROP3_HANDLERS(DSPnax, (~*pat & *src) ^ *dest, 0xa6);
-ROP3_HANDLERS(PDSPoaxn, ~(((*pat | *src) & *dest) ^ *pat), 0xa7);
-ROP3_HANDLERS(DPSoa, (*src | *pat) & *dest, 0xa8);
-ROP3_HANDLERS(DPSoxn, ~((*src | *pat) ^ *dest), 0xa9);
-ROP3_HANDLERS(DPSono, ~(*src | *pat) | *dest, 0xab);
-ROP3_HANDLERS(SPDSxax, ((*src ^ *dest) & *pat) ^ *src, 0xac);
-ROP3_HANDLERS(DPSDaoxn, ~(((*dest & *src) | *pat) ^ *dest), 0xad);
-ROP3_HANDLERS(DSPnao, (~*pat & *src) | *dest, 0xae);
-ROP3_HANDLERS(PDSnoa, (~*src | *dest) & *pat, 0xb0);
-ROP3_HANDLERS(PDSPxoxn, ~(((*pat ^ *src) | *dest) ^ *pat), 0xb1);
-ROP3_HANDLERS(SSPxDSxox, ((*src ^ *dest) | (*pat ^ *src)) ^ *src, 0xb2);
-ROP3_HANDLERS(SDPanan, ~(~(*pat & *dest) & *src), 0xb3);
-ROP3_HANDLERS(PSDnax, (~*dest & *src) ^ *pat, 0xb4);
-ROP3_HANDLERS(DPSDoaxn, ~(((*dest | *src) & *pat) ^ *dest), 0xb5);
-ROP3_HANDLERS(DPSDPaoxx, ((*pat & *dest) | *src) ^ *pat ^ *dest, 0xb6);
-ROP3_HANDLERS(SDPxan, ~((*pat ^ *dest) & *src), 0xb7);
-ROP3_HANDLERS(PSDPxax, ((*dest ^ *pat) & *src) ^ *pat, 0xb8);
-ROP3_HANDLERS(DSPDaoxn, ~(((*dest & *pat) | *src) ^ *dest), 0xb9);
-ROP3_HANDLERS(DPSnao, (~*src & *pat) | *dest, 0xba);
-ROP3_HANDLERS(SPDSanax, (~(*src & *dest) & *pat) ^ *src, 0xbc);
-ROP3_HANDLERS(SDxPDxan, ~((*dest ^ *pat) & (*dest ^ *src)), 0xbd);
-ROP3_HANDLERS(DPSxo, (*src ^ *pat) | *dest, 0xbe);
-ROP3_HANDLERS(DPSano, ~(*src & *pat) | *dest, 0xbf);
-ROP3_HANDLERS(SPDSnaoxn, ~(((~*src & *dest) | *pat) ^ *src), 0xc1);
-ROP3_HANDLERS(SPDSonoxn, ~((~(*src | *dest) | *pat) ^ *src), 0xc2);
-ROP3_HANDLERS(SPDnoa, (~*dest | *pat) & *src, 0xc4);
-ROP3_HANDLERS(SPDSxoxn, ~(((*src ^ *dest) | *pat) ^ *src), 0xc5);
-ROP3_HANDLERS(SDPnax, (~*pat & *dest) ^ *src, 0xc6);
-ROP3_HANDLERS(PSDPoaxn, ~(((*pat | *dest) & *src) ^ *pat), 0xc7);
-ROP3_HANDLERS(SDPoa, (*pat | *dest) & *src, 0xc8);
-ROP3_HANDLERS(SPDoxn, ~((*dest | *pat) ^ *src), 0xc9);
-ROP3_HANDLERS(DPSDxax, ((*dest ^ *src) & *pat) ^ *dest, 0xca);
-ROP3_HANDLERS(SPDSaoxn, ~(((*src & *dest) | *pat) ^ *src), 0xcb);
-ROP3_HANDLERS(SDPono, ~(*pat | *dest) | *src, 0xcd);
-ROP3_HANDLERS(SDPnao, (~*pat & *dest) | *src, 0xce);
-ROP3_HANDLERS(PSDnoa, (~*dest | *src) & *pat, 0xd0);
-ROP3_HANDLERS(PSDPxoxn, ~(((*pat ^ *dest) | *src) ^ *pat), 0xd1);
-ROP3_HANDLERS(PDSnax, (~*src & *dest) ^ *pat, 0xd2);
-ROP3_HANDLERS(SPDSoaxn, ~(((*src | *dest) & *pat) ^ *src), 0xd3);
-ROP3_HANDLERS(SSPxPDxax, ((*dest ^ *pat) & (*pat ^ *src)) ^ *src, 0xd4);
-ROP3_HANDLERS(DPSanan, ~(~(*src & *pat) & *dest), 0xd5);
-ROP3_HANDLERS(PSDPSaoxx, ((*src & *pat) | *dest) ^ *src ^ *pat, 0xd6);
-ROP3_HANDLERS(DPSxan, ~((*src ^ *pat) & *dest), 0xd7);
-ROP3_HANDLERS(PDSPxax, ((*pat ^ *src) & *dest) ^ *pat, 0xd8);
-ROP3_HANDLERS(SDPSaoxn, ~(((*src & *pat) | *dest) ^ *src), 0xd9);
-ROP3_HANDLERS(DPSDanax, (~(*dest & *src) & *pat) ^ *dest, 0xda);
-ROP3_HANDLERS(SPxDSxan, ~((*src ^ *dest) & (*pat ^ *src)), 0xdb);
-ROP3_HANDLERS(SPDnao, (~*dest & *pat) | *src, 0xdc);
-ROP3_HANDLERS(SDPxo, (*pat ^ *dest) | *src, 0xde);
-ROP3_HANDLERS(SDPano, ~(*pat & *dest) | *src, 0xdf);
-ROP3_HANDLERS(PDSoa, (*src | *dest) & *pat, 0xe0);
-ROP3_HANDLERS(PDSoxn, ~((*src | *dest) ^ *pat), 0xe1);
-ROP3_HANDLERS(DSPDxax, ((*dest ^ *pat) & *src) ^ *dest, 0xe2);
-ROP3_HANDLERS(PSDPaoxn, ~(((*pat & *dest) | *src) ^ *pat), 0xe3);
-ROP3_HANDLERS(SDPSxax, ((*src ^ *pat) & *dest) ^ *src, 0xe4);
-ROP3_HANDLERS(PDSPaoxn, ~(((*pat & *src) | *dest) ^ *pat), 0xe5);
-ROP3_HANDLERS(SDPSanax, (~(*src & *pat) & *dest) ^ *src, 0xe6);
-ROP3_HANDLERS(SPxPDxan, ~((*dest ^ *pat) & (*pat ^ *src)), 0xe7);
-ROP3_HANDLERS(SSPxDSxax, ((*src ^ *dest) & (*pat ^ *src)) ^ *src, 0xe8);
-ROP3_HANDLERS(DSPDSanaxxn, ~((~(*src & *dest) & *pat) ^ *src ^ *dest), 0xe9);
-ROP3_HANDLERS(DPSao, (*src & *pat) | *dest, 0xea);
-ROP3_HANDLERS(DPSxno, ~(*src ^ *pat) | *dest, 0xeb);
-ROP3_HANDLERS(SDPao, (*pat & *dest) | *src, 0xec);
-ROP3_HANDLERS(SDPxno, ~(*pat ^ *dest) | *src, 0xed);
-ROP3_HANDLERS(SDPnoo, ~*pat | *dest | *src, 0xef);
-ROP3_HANDLERS(PDSono, ~(*src | *dest) | *pat, 0xf1);
-ROP3_HANDLERS(PDSnao, (~*src & *dest) | *pat, 0xf2);
-ROP3_HANDLERS(PSDnao, (~*dest & *src) | *pat, 0xf4);
-ROP3_HANDLERS(PDSxo, (*src ^ *dest) | *pat, 0xf6);
-ROP3_HANDLERS(PDSano, ~(*src & *dest) | *pat, 0xf7);
-ROP3_HANDLERS(PDSao, (*src & *dest) | *pat, 0xf8);
-ROP3_HANDLERS(PDSxno, ~(*src ^ *dest) | *pat, 0xf9);
-ROP3_HANDLERS(DPSnoo, ~*src | *pat | *dest, 0xfb);
-ROP3_HANDLERS(PSDnoo, ~*dest | *src | *pat, 0xfd);
-ROP3_HANDLERS(DPSoo, *src | *pat | *dest, 0xfe);
-
-
-#define ROP3_FILL_HANDLERS(op, index) \
- rop3_with_pattern_handlers_32[index] = rop3_handle_p32_##op; \
- rop3_with_pattern_handlers_16[index] = rop3_handle_p16_##op; \
- rop3_with_color_handlers_32[index] = rop3_handle_c32_##op; \
- rop3_with_color_handlers_16[index] = rop3_handle_c16_##op; \
- rop3_test_handlers_32[index] = rop3_test32_##op; \
- rop3_test_handlers_16[index] = rop3_test16_##op;
-
-void rop3_init(void)
-{
- static int need_init = 1;
- int i;
-
- if (!need_init) {
- return;
- }
- need_init = 0;
-
- for (i = 0; i < ROP3_NUM_OPS; i++) {
- rop3_with_pattern_handlers_32[i] = default_rop3_with_pattern_handler;
- rop3_with_pattern_handlers_16[i] = default_rop3_with_pattern_handler;
- rop3_with_color_handlers_32[i] = default_rop3_withe_color_handler;
- rop3_with_color_handlers_16[i] = default_rop3_withe_color_handler;
- rop3_test_handlers_32[i] = default_rop3_test_handler;
- rop3_test_handlers_16[i] = default_rop3_test_handler;
- }
-
- ROP3_FILL_HANDLERS(DPSoon, 0x01);
- ROP3_FILL_HANDLERS(DPSona, 0x02);
- ROP3_FILL_HANDLERS(SDPona, 0x04);
- ROP3_FILL_HANDLERS(PDSxnon, 0x06);
- ROP3_FILL_HANDLERS(PDSaon, 0x07);
- ROP3_FILL_HANDLERS(SDPnaa, 0x08);
- ROP3_FILL_HANDLERS(PDSxon, 0x09);
- ROP3_FILL_HANDLERS(PSDnaon, 0x0b);
- ROP3_FILL_HANDLERS(PDSnaon, 0x0d);
- ROP3_FILL_HANDLERS(PDSonon, 0x0e);
- ROP3_FILL_HANDLERS(PDSona, 0x10);
- ROP3_FILL_HANDLERS(SDPxnon, 0x12);
- ROP3_FILL_HANDLERS(SDPaon, 0x13);
- ROP3_FILL_HANDLERS(DPSxnon, 0x14);
- ROP3_FILL_HANDLERS(DPSaon, 0x15);
- ROP3_FILL_HANDLERS(PSDPSanaxx, 0x16);
- ROP3_FILL_HANDLERS(SSPxDSxaxn, 0x17);
- ROP3_FILL_HANDLERS(SPxPDxa, 0x18);
- ROP3_FILL_HANDLERS(SDPSanaxn, 0x19);
- ROP3_FILL_HANDLERS(PDSPaox, 0x1a);
- ROP3_FILL_HANDLERS(SDPSxaxn, 0x1b);
- ROP3_FILL_HANDLERS(PSDPaox, 0x1c);
- ROP3_FILL_HANDLERS(DSPDxaxn, 0x1d);
- ROP3_FILL_HANDLERS(PDSox, 0x1e);
- ROP3_FILL_HANDLERS(PDSoan, 0x1f);
- ROP3_FILL_HANDLERS(DPSnaa, 0x20);
- ROP3_FILL_HANDLERS(SDPxon, 0x21);
- ROP3_FILL_HANDLERS(SPDnaon, 0x23);
- ROP3_FILL_HANDLERS(SPxDSxa, 0x24);
- ROP3_FILL_HANDLERS(PDSPanaxn, 0x25);
- ROP3_FILL_HANDLERS(SDPSaox, 0x26);
- ROP3_FILL_HANDLERS(SDPSxnox, 0x27);
- ROP3_FILL_HANDLERS(DPSxa, 0x28);
- ROP3_FILL_HANDLERS(PSDPSaoxxn, 0x29);
- ROP3_FILL_HANDLERS(DPSana, 0x2a);
- ROP3_FILL_HANDLERS(SSPxPDxaxn, 0x2b);
- ROP3_FILL_HANDLERS(SPDSoax, 0x2c);
- ROP3_FILL_HANDLERS(PSDnox, 0x2d);
- ROP3_FILL_HANDLERS(PSDPxox, 0x2e);
- ROP3_FILL_HANDLERS(PSDnoan, 0x2f);
- ROP3_FILL_HANDLERS(SDPnaon, 0x31);
- ROP3_FILL_HANDLERS(SDPSoox, 0x32);
- ROP3_FILL_HANDLERS(SPDSaox, 0x34);
- ROP3_FILL_HANDLERS(SPDSxnox, 0x35);
- ROP3_FILL_HANDLERS(SDPox, 0x36);
- ROP3_FILL_HANDLERS(SDPoan, 0x37);
- ROP3_FILL_HANDLERS(PSDPoax, 0x38);
- ROP3_FILL_HANDLERS(SPDnox, 0x39);
- ROP3_FILL_HANDLERS(SPDSxox, 0x3a);
- ROP3_FILL_HANDLERS(SPDnoan, 0x3b);
- ROP3_FILL_HANDLERS(SPDSonox, 0x3d);
- ROP3_FILL_HANDLERS(SPDSnaox, 0x3e);
- ROP3_FILL_HANDLERS(PSDnaa, 0x40);
- ROP3_FILL_HANDLERS(DPSxon, 0x41);
- ROP3_FILL_HANDLERS(SDxPDxa, 0x42);
- ROP3_FILL_HANDLERS(SPDSanaxn, 0x43);
- ROP3_FILL_HANDLERS(DPSnaon, 0x45);
- ROP3_FILL_HANDLERS(DSPDaox, 0x46);
- ROP3_FILL_HANDLERS(PSDPxaxn, 0x47);
- ROP3_FILL_HANDLERS(SDPxa, 0x48);
- ROP3_FILL_HANDLERS(PDSPDaoxxn, 0x49);
- ROP3_FILL_HANDLERS(DPSDoax, 0x4a);
- ROP3_FILL_HANDLERS(PDSnox, 0x4b);
- ROP3_FILL_HANDLERS(SDPana, 0x4c);
- ROP3_FILL_HANDLERS(SSPxDSxoxn, 0x4d);
- ROP3_FILL_HANDLERS(PDSPxox, 0x4e);
- ROP3_FILL_HANDLERS(PDSnoan, 0x4f);
- ROP3_FILL_HANDLERS(DSPnaon, 0x51);
- ROP3_FILL_HANDLERS(DPSDaox, 0x52);
- ROP3_FILL_HANDLERS(SPDSxaxn, 0x53);
- ROP3_FILL_HANDLERS(DPSonon, 0x54);
- ROP3_FILL_HANDLERS(DPSox, 0x56);
- ROP3_FILL_HANDLERS(DPSoan, 0x57);
- ROP3_FILL_HANDLERS(PDSPoax, 0x58);
- ROP3_FILL_HANDLERS(DPSnox, 0x59);
- ROP3_FILL_HANDLERS(DPSDonox, 0x5b);
- ROP3_FILL_HANDLERS(DPSDxox, 0x5c);
- ROP3_FILL_HANDLERS(DPSnoan, 0x5d);
- ROP3_FILL_HANDLERS(DPSDnaox, 0x5e);
- ROP3_FILL_HANDLERS(PDSxa, 0x60);
- ROP3_FILL_HANDLERS(DSPDSaoxxn, 0x61);
- ROP3_FILL_HANDLERS(DSPDoax, 0x62);
- ROP3_FILL_HANDLERS(SDPnox, 0x63);
- ROP3_FILL_HANDLERS(SDPSoax, 0x64);
- ROP3_FILL_HANDLERS(DSPnox, 0x65);
- ROP3_FILL_HANDLERS(SDPSonox, 0x67);
- ROP3_FILL_HANDLERS(DSPDSonoxxn, 0x68);
- ROP3_FILL_HANDLERS(PDSxxn, 0x69);
- ROP3_FILL_HANDLERS(DPSax, 0x6a);
- ROP3_FILL_HANDLERS(PSDPSoaxxn, 0x6b);
- ROP3_FILL_HANDLERS(SDPax, 0x6c);
- ROP3_FILL_HANDLERS(PDSPDoaxxn, 0x6d);
- ROP3_FILL_HANDLERS(SDPSnoax, 0x6e);
- ROP3_FILL_HANDLERS(PDSxnan, 0x6f);
- ROP3_FILL_HANDLERS(PDSana, 0x70);
- ROP3_FILL_HANDLERS(SSDxPDxaxn, 0x71);
- ROP3_FILL_HANDLERS(SDPSxox, 0x72);
- ROP3_FILL_HANDLERS(SDPnoan, 0x73);
- ROP3_FILL_HANDLERS(DSPDxox, 0x74);
- ROP3_FILL_HANDLERS(DSPnoan, 0x75);
- ROP3_FILL_HANDLERS(SDPSnaox, 0x76);
- ROP3_FILL_HANDLERS(PDSax, 0x78);
- ROP3_FILL_HANDLERS(DSPDSoaxxn, 0x79);
- ROP3_FILL_HANDLERS(DPSDnoax, 0x7a);
- ROP3_FILL_HANDLERS(SDPxnan, 0x7b);
- ROP3_FILL_HANDLERS(SPDSnoax, 0x7c);
- ROP3_FILL_HANDLERS(DPSxnan, 0x7d);
- ROP3_FILL_HANDLERS(SPxDSxo, 0x7e);
- ROP3_FILL_HANDLERS(DPSaan, 0x7f);
- ROP3_FILL_HANDLERS(DPSaa, 0x80);
- ROP3_FILL_HANDLERS(SPxDSxon, 0x81);
- ROP3_FILL_HANDLERS(DPSxna, 0x82);
- ROP3_FILL_HANDLERS(SPDSnoaxn, 0x83);
- ROP3_FILL_HANDLERS(SDPxna, 0x84);
- ROP3_FILL_HANDLERS(PDSPnoaxn, 0x85);
- ROP3_FILL_HANDLERS(DSPDSoaxx, 0x86);
- ROP3_FILL_HANDLERS(PDSaxn, 0x87);
- ROP3_FILL_HANDLERS(SDPSnaoxn, 0x89);
- ROP3_FILL_HANDLERS(DSPnoa, 0x8a);
- ROP3_FILL_HANDLERS(DSPDxoxn, 0x8b);
- ROP3_FILL_HANDLERS(SDPnoa, 0x8c);
- ROP3_FILL_HANDLERS(SDPSxoxn, 0x8d);
- ROP3_FILL_HANDLERS(SSDxPDxax, 0x8e);
- ROP3_FILL_HANDLERS(PDSanan, 0x8f);
- ROP3_FILL_HANDLERS(PDSxna, 0x90);
- ROP3_FILL_HANDLERS(SDPSnoaxn, 0x91);
- ROP3_FILL_HANDLERS(DPSDPoaxx, 0x92);
- ROP3_FILL_HANDLERS(SPDaxn, 0x93);
- ROP3_FILL_HANDLERS(PSDPSoaxx, 0x94);
- ROP3_FILL_HANDLERS(DPSaxn, 0x95);
- ROP3_FILL_HANDLERS(DPSxx, 0x96);
- ROP3_FILL_HANDLERS(PSDPSonoxx, 0x97);
- ROP3_FILL_HANDLERS(SDPSonoxn, 0x98);
- ROP3_FILL_HANDLERS(DPSnax, 0x9a);
- ROP3_FILL_HANDLERS(SDPSoaxn, 0x9b);
- ROP3_FILL_HANDLERS(SPDnax, 0x9c);
- ROP3_FILL_HANDLERS(DSPDoaxn, 0x9d);
- ROP3_FILL_HANDLERS(DSPDSaoxx, 0x9e);
- ROP3_FILL_HANDLERS(PDSxan, 0x9f);
- ROP3_FILL_HANDLERS(PDSPnaoxn, 0xa1);
- ROP3_FILL_HANDLERS(DPSnoa, 0xa2);
- ROP3_FILL_HANDLERS(DPSDxoxn, 0xa3);
- ROP3_FILL_HANDLERS(PDSPonoxn, 0xa4);
- ROP3_FILL_HANDLERS(DSPnax, 0xa6);
- ROP3_FILL_HANDLERS(PDSPoaxn, 0xa7);
- ROP3_FILL_HANDLERS(DPSoa, 0xa8);
- ROP3_FILL_HANDLERS(DPSoxn, 0xa9);
- ROP3_FILL_HANDLERS(DPSono, 0xab);
- ROP3_FILL_HANDLERS(SPDSxax, 0xac);
- ROP3_FILL_HANDLERS(DPSDaoxn, 0xad);
- ROP3_FILL_HANDLERS(DSPnao, 0xae);
- ROP3_FILL_HANDLERS(PDSnoa, 0xb0);
- ROP3_FILL_HANDLERS(PDSPxoxn, 0xb1);
- ROP3_FILL_HANDLERS(SSPxDSxox, 0xb2);
- ROP3_FILL_HANDLERS(SDPanan, 0xb3);
- ROP3_FILL_HANDLERS(PSDnax, 0xb4);
- ROP3_FILL_HANDLERS(DPSDoaxn, 0xb5);
- ROP3_FILL_HANDLERS(DPSDPaoxx, 0xb6);
- ROP3_FILL_HANDLERS(SDPxan, 0xb7);
- ROP3_FILL_HANDLERS(PSDPxax, 0xb8);
- ROP3_FILL_HANDLERS(DSPDaoxn, 0xb9);
- ROP3_FILL_HANDLERS(DPSnao, 0xba);
- ROP3_FILL_HANDLERS(SPDSanax, 0xbc);
- ROP3_FILL_HANDLERS(SDxPDxan, 0xbd);
- ROP3_FILL_HANDLERS(DPSxo, 0xbe);
- ROP3_FILL_HANDLERS(DPSano, 0xbf);
- ROP3_FILL_HANDLERS(SPDSnaoxn, 0xc1);
- ROP3_FILL_HANDLERS(SPDSonoxn, 0xc2);
- ROP3_FILL_HANDLERS(SPDnoa, 0xc4);
- ROP3_FILL_HANDLERS(SPDSxoxn, 0xc5);
- ROP3_FILL_HANDLERS(SDPnax, 0xc6);
- ROP3_FILL_HANDLERS(PSDPoaxn, 0xc7);
- ROP3_FILL_HANDLERS(SDPoa, 0xc8);
- ROP3_FILL_HANDLERS(SPDoxn, 0xc9);
- ROP3_FILL_HANDLERS(DPSDxax, 0xca);
- ROP3_FILL_HANDLERS(SPDSaoxn, 0xcb);
- ROP3_FILL_HANDLERS(SDPono, 0xcd);
- ROP3_FILL_HANDLERS(SDPnao, 0xce);
- ROP3_FILL_HANDLERS(PSDnoa, 0xd0);
- ROP3_FILL_HANDLERS(PSDPxoxn, 0xd1);
- ROP3_FILL_HANDLERS(PDSnax, 0xd2);
- ROP3_FILL_HANDLERS(SPDSoaxn, 0xd3);
- ROP3_FILL_HANDLERS(SSPxPDxax, 0xd4);
- ROP3_FILL_HANDLERS(DPSanan, 0xd5);
- ROP3_FILL_HANDLERS(PSDPSaoxx, 0xd6);
- ROP3_FILL_HANDLERS(DPSxan, 0xd7);
- ROP3_FILL_HANDLERS(PDSPxax, 0xd8);
- ROP3_FILL_HANDLERS(SDPSaoxn, 0xd9);
- ROP3_FILL_HANDLERS(DPSDanax, 0xda);
- ROP3_FILL_HANDLERS(SPxDSxan, 0xdb);
- ROP3_FILL_HANDLERS(SPDnao, 0xdc);
- ROP3_FILL_HANDLERS(SDPxo, 0xde);
- ROP3_FILL_HANDLERS(SDPano, 0xdf);
- ROP3_FILL_HANDLERS(PDSoa, 0xe0);
- ROP3_FILL_HANDLERS(PDSoxn, 0xe1);
- ROP3_FILL_HANDLERS(DSPDxax, 0xe2);
- ROP3_FILL_HANDLERS(PSDPaoxn, 0xe3);
- ROP3_FILL_HANDLERS(SDPSxax, 0xe4);
- ROP3_FILL_HANDLERS(PDSPaoxn, 0xe5);
- ROP3_FILL_HANDLERS(SDPSanax, 0xe6);
- ROP3_FILL_HANDLERS(SPxPDxan, 0xe7);
- ROP3_FILL_HANDLERS(SSPxDSxax, 0xe8);
- ROP3_FILL_HANDLERS(DSPDSanaxxn, 0xe9);
- ROP3_FILL_HANDLERS(DPSao, 0xea);
- ROP3_FILL_HANDLERS(DPSxno, 0xeb);
- ROP3_FILL_HANDLERS(SDPao, 0xec);
- ROP3_FILL_HANDLERS(SDPxno, 0xed);
- ROP3_FILL_HANDLERS(SDPnoo, 0xef);
- ROP3_FILL_HANDLERS(PDSono, 0xf1);
- ROP3_FILL_HANDLERS(PDSnao, 0xf2);
- ROP3_FILL_HANDLERS(PSDnao, 0xf4);
- ROP3_FILL_HANDLERS(PDSxo, 0xf6);
- ROP3_FILL_HANDLERS(PDSano, 0xf7);
- ROP3_FILL_HANDLERS(PDSao, 0xf8);
- ROP3_FILL_HANDLERS(PDSxno, 0xf9);
- ROP3_FILL_HANDLERS(DPSnoo, 0xfb);
- ROP3_FILL_HANDLERS(PSDnoo, 0xfd);
- ROP3_FILL_HANDLERS(DPSoo, 0xfe);
-
- for (i = 0; i < ROP3_NUM_OPS; i++) {
- rop3_test_handlers_32[i]();
- rop3_test_handlers_16[i]();
- }
-}
-
-void do_rop3_with_pattern(uint8_t rop3, pixman_image_t *d, pixman_image_t *s, SpicePoint *src_pos,
- pixman_image_t *p, SpicePoint *pat_pos)
-{
- int bpp;
-
- bpp = spice_pixman_image_get_bpp(d);
- ASSERT (bpp == spice_pixman_image_get_bpp(s));
- ASSERT (bpp == spice_pixman_image_get_bpp(p));
-
- if (bpp == 32) {
- rop3_with_pattern_handlers_32[rop3](d, s, src_pos, p, pat_pos);
- } else {
- rop3_with_pattern_handlers_16[rop3](d, s, src_pos, p, pat_pos);
- }
-}
-
-void do_rop3_with_color(uint8_t rop3, pixman_image_t *d, pixman_image_t *s, SpicePoint *src_pos,
- uint32_t rgb)
-{
- int bpp;
-
- bpp = spice_pixman_image_get_bpp(d);
- ASSERT (bpp == spice_pixman_image_get_bpp(s));
-
- if (bpp == 32) {
- rop3_with_color_handlers_32[rop3](d, s, src_pos, rgb);
- } else {
- rop3_with_color_handlers_16[rop3](d, s, src_pos, rgb);
- }
-}
diff --git a/common/rop3.h b/common/rop3.h
deleted file mode 100644
index 91c9207..0000000
--- a/common/rop3.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H_ROP3
-#define _H_ROP3
-
-#include <stdint.h>
-
-#include "draw.h"
-#include "pixman_utils.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void do_rop3_with_pattern(uint8_t rop3, pixman_image_t *d, pixman_image_t *s, SpicePoint *src_pos,
- pixman_image_t *p, SpicePoint *pat_pos);
-void do_rop3_with_color(uint8_t rop3, pixman_image_t *d, pixman_image_t *s, SpicePoint *src_pos,
- uint32_t rgb);
-
-void rop3_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/spice_common.h b/common/spice_common.h
deleted file mode 100644
index 434b179..0000000
--- a/common/spice_common.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef H_SPICE_COMMON
-#define H_SPICE_COMMON
-
-#include <stdio.h>
-#include <stdint.h>
-#include <time.h>
-#include <stdlib.h>
-#include "backtrace.h"
-
-#define ASSERT(x) if (!(x)) { \
- printf("%s: ASSERT %s failed\n", __FUNCTION__, #x); \
- spice_backtrace(); \
- abort(); \
-}
-
-#define PANIC(format, ...) do { \
- printf("%s: panic: " format "\n", __FUNCTION__, ## __VA_ARGS__ ); \
- abort(); \
-} while (0)
-
-#define PANIC_ON(x) if ((x)) { \
- printf("%s: panic %s\n", __FUNCTION__, #x); \
- abort(); \
-}
-
-#define red_error(format, ...) do { \
- printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ ); \
- abort(); \
-} while (0)
-#define red_printf(format, ...) \
- printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ )
-
-#define red_printf_once(format, ...) do { \
- static int do_print = TRUE; \
- if (do_print) { \
- do_print = FALSE; \
- printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ ); \
- } \
-} while (0)
-
-#define WARN(format, ...) red_printf("warning: "format, ##__VA_ARGS__ );
-#define WARN_ONCE red_printf_once
-
-#define red_printf_some(every, format, ...) do { \
- static int count = 0; \
- if (count++ % (every) == 0) { \
- printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ ); \
- } \
-} while (0)
-
-#define red_printf_debug(debug, prefix, format, ...) do { \
- static int debug_level = -1; \
- if (debug_level == -1) { \
- debug_level = getenv("SPICE_DEBUG_LEVEL") != NULL ? atoi(getenv("SPICE_DEBUG_LEVEL")) : 0; \
- } \
- if (debug <= debug_level) { \
- printf("%s: %s: " format "\n", prefix, __FUNCTION__, ## __VA_ARGS__ ); \
- } \
-} while(0)
-
-#endif
diff --git a/common/ssl_verify.c b/common/ssl_verify.c
deleted file mode 100644
index 603d0f3..0000000
--- a/common/ssl_verify.c
+++ /dev/null
@@ -1,482 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2011 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "mem.h"
-#include "ssl_verify.h"
-
-#ifndef WIN32
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#endif
-#include <ctype.h>
-
-#ifndef SPICE_DEBUG
-# define SPICE_DEBUG(format, ...)
-#endif
-
-#ifdef WIN32
-static int inet_aton(const char* ip, struct in_addr* in_addr)
-{
- unsigned long addr = inet_addr(ip);
-
- if (addr == INADDR_NONE) {
- return 0;
- }
- in_addr->S_un.S_addr = addr;
- return 1;
-}
-#endif
-
-static int verify_pubkey(X509* cert, const char *key, size_t key_size)
-{
- EVP_PKEY* cert_pubkey = NULL;
- EVP_PKEY* orig_pubkey = NULL;
- BIO* bio = NULL;
- int ret = 0;
-
- if (!key || key_size == 0)
- return 0;
-
- if (!cert) {
- SPICE_DEBUG("warning: no cert!");
- return 0;
- }
-
- cert_pubkey = X509_get_pubkey(cert);
- if (!cert_pubkey) {
- SPICE_DEBUG("warning: reading public key from certificate failed");
- goto finish;
- }
-
- bio = BIO_new_mem_buf((void*)key, key_size);
- if (!bio) {
- SPICE_DEBUG("creating BIO failed");
- goto finish;
- }
-
- orig_pubkey = d2i_PUBKEY_bio(bio, NULL);
- if (!orig_pubkey) {
- SPICE_DEBUG("reading pubkey from bio failed");
- goto finish;
- }
-
- ret = EVP_PKEY_cmp(orig_pubkey, cert_pubkey);
-
- if (ret == 1)
- SPICE_DEBUG("public keys match");
- else if (ret == 0)
- SPICE_DEBUG("public keys mismatch");
- else
- SPICE_DEBUG("public keys types mismatch");
-
-finish:
- if (bio)
- BIO_free(bio);
-
- if (orig_pubkey)
- EVP_PKEY_free(orig_pubkey);
-
- if (cert_pubkey)
- EVP_PKEY_free(cert_pubkey);
-
- return ret;
-}
-
-/* from gnutls
- * compare hostname against certificate, taking account of wildcards
- * return 1 on success or 0 on error
- *
- * note: certnamesize is required as X509 certs can contain embedded NULs in
- * the strings such as CN or subjectAltName
- */
-static int _gnutls_hostname_compare(const char *certname,
- size_t certnamesize, const char *hostname)
-{
- /* find the first different character */
- for (; *certname && *hostname && toupper (*certname) == toupper (*hostname);
- certname++, hostname++, certnamesize--)
- ;
-
- /* the strings are the same */
- if (certnamesize == 0 && *hostname == '\0')
- return 1;
-
- if (*certname == '*')
- {
- /* a wildcard certificate */
-
- certname++;
- certnamesize--;
-
- while (1)
- {
- /* Use a recursive call to allow multiple wildcards */
- if (_gnutls_hostname_compare (certname, certnamesize, hostname))
- return 1;
-
- /* wildcards are only allowed to match a single domain
- component or component fragment */
- if (*hostname == '\0' || *hostname == '.')
- break;
- hostname++;
- }
-
- return 0;
- }
-
- return 0;
-}
-
-/**
- * From gnutls and spice red_peer.c
- * TODO: switch to gnutls and get rid of this
- *
- * This function will check if the given certificate's subject matches
- * the given hostname. This is a basic implementation of the matching
- * described in RFC2818 (HTTPS), which takes into account wildcards,
- * and the DNSName/IPAddress subject alternative name PKIX extension.
- *
- * Returns: 1 for a successful match, and 0 on failure.
- **/
-static int verify_hostname(X509* cert, const char *hostname)
-{
- GENERAL_NAMES* subject_alt_names;
- int found_dns_name = 0;
- struct in_addr addr;
- int addr_len = 0;
- int cn_match = 0;
- X509_NAME* subject;
-
- if (!cert) {
- SPICE_DEBUG("warning: no cert!");
- return 0;
- }
-
- // only IpV4 supported
- if (inet_aton(hostname, &addr)) {
- addr_len = sizeof(struct in_addr);
- }
-
- /* try matching against:
- * 1) a DNS name as an alternative name (subjectAltName) extension
- * in the certificate
- * 2) the common name (CN) in the certificate
- *
- * either of these may be of the form: *.domain.tld
- *
- * only try (2) if there is no subjectAltName extension of
- * type dNSName
- */
-
- /* Check through all included subjectAltName extensions, comparing
- * against all those of type dNSName.
- */
- subject_alt_names = (GENERAL_NAMES*)X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
-
- if (subject_alt_names) {
- int num_alts = sk_GENERAL_NAME_num(subject_alt_names);
- int i;
- for (i = 0; i < num_alts; i++) {
- const GENERAL_NAME* name = sk_GENERAL_NAME_value(subject_alt_names, i);
- if (name->type == GEN_DNS) {
- found_dns_name = 1;
- if (_gnutls_hostname_compare((char *)ASN1_STRING_data(name->d.dNSName),
- ASN1_STRING_length(name->d.dNSName),
- hostname)) {
- SPICE_DEBUG("alt name match=%s", ASN1_STRING_data(name->d.dNSName));
- GENERAL_NAMES_free(subject_alt_names);
- return 1;
- }
- } else if (name->type == GEN_IPADD) {
- int alt_ip_len = ASN1_STRING_length(name->d.iPAddress);
- found_dns_name = 1;
- if ((addr_len == alt_ip_len)&&
- !memcmp(ASN1_STRING_data(name->d.iPAddress), &addr, addr_len)) {
- SPICE_DEBUG("alt name IP match=%s",
- inet_ntoa(*((struct in_addr*)ASN1_STRING_data(name->d.dNSName))));
- GENERAL_NAMES_free(subject_alt_names);
- return 1;
- }
- }
- }
- GENERAL_NAMES_free(subject_alt_names);
- }
-
- if (found_dns_name) {
- SPICE_DEBUG("warning: SubjectAltName mismatch");
- return 0;
- }
-
- /* extracting commonNames */
- subject = X509_get_subject_name(cert);
- if (subject) {
- int pos = -1;
- X509_NAME_ENTRY* cn_entry;
- ASN1_STRING* cn_asn1;
-
- while ((pos = X509_NAME_get_index_by_NID(subject, NID_commonName, pos)) != -1) {
- cn_entry = X509_NAME_get_entry(subject, pos);
- if (!cn_entry) {
- continue;
- }
- cn_asn1 = X509_NAME_ENTRY_get_data(cn_entry);
- if (!cn_asn1) {
- continue;
- }
-
- if (_gnutls_hostname_compare((char*)ASN1_STRING_data(cn_asn1),
- ASN1_STRING_length(cn_asn1),
- hostname)) {
- SPICE_DEBUG("common name match=%s", (char*)ASN1_STRING_data(cn_asn1));
- cn_match = 1;
- break;
- }
- }
- }
-
- if (!cn_match)
- SPICE_DEBUG("warning: common name mismatch");
-
- return cn_match;
-}
-
-X509_NAME* subject_to_x509_name(const char *subject, int *nentries)
-{
- X509_NAME* in_subject;
- const char *p;
- char *key, *val, *k, *v = NULL;
- enum {
- KEY,
- VALUE
- } state;
-
- key = (char*)alloca(strlen(subject));
- val = (char*)alloca(strlen(subject));
- in_subject = X509_NAME_new();
-
- if (!in_subject || !key || !val) {
- SPICE_DEBUG("failed to allocate");
- return NULL;
- }
-
- *nentries = 0;
-
- k = key;
- state = KEY;
- for (p = subject;; ++p) {
- int escape = 0;
- if (*p == '\\') {
- ++p;
- if (*p != '\\' && *p != ',') {
- SPICE_DEBUG("Invalid character after \\");
- goto fail;
- }
- escape = 1;
- }
-
- switch (state) {
- case KEY:
- if (*p == ' ' && k == key) {
- continue; /* skip spaces before key */
- } if (*p == 0) {
- if (k == key) /* empty key, ending */
- goto success;
- goto fail;
- } else if (*p == ',' && !escape) {
- goto fail; /* assignment is missing */
- } else if (*p == '=' && !escape) {
- state = VALUE;
- *k = 0;
- v = val;
- } else
- *k++ = *p;
- break;
- case VALUE:
- if (*p == 0 || (*p == ',' && !escape)) {
- if (v == val) /* empty value */
- goto fail;
-
- *v = 0;
-
- if (!X509_NAME_add_entry_by_txt(in_subject, key,
- MBSTRING_UTF8,
- (const unsigned char*)val,
- -1, -1, 0)) {
- SPICE_DEBUG("warning: failed to add entry %s=%s to X509_NAME",
- key, val);
- goto fail;
- }
- *nentries += 1;
-
- if (*p == 0)
- goto success;
-
- state = KEY;
- k = key;
- } else
- *v++ = *p;
- break;
- }
- }
-
-success:
- return in_subject;
-
-fail:
- if (in_subject)
- X509_NAME_free(in_subject);
-
- return NULL;
-}
-
-int verify_subject(X509* cert, SpiceOpenSSLVerify* verify)
-{
- X509_NAME *cert_subject = NULL;
- int ret;
- int in_entries;
-
- if (!cert) {
- SPICE_DEBUG("warning: no cert!");
- return 0;
- }
-
- cert_subject = X509_get_subject_name(cert);
- if (!cert_subject) {
- SPICE_DEBUG("warning: reading certificate subject failed");
- return 0;
- }
-
- if (!verify->in_subject) {
- verify->in_subject = subject_to_x509_name(verify->subject, &in_entries);
- if (!verify->in_subject) {
- SPICE_DEBUG("warning: no in_subject!");
- return 0;
- }
- }
-
- /* Note: this check is redundant with the pre-condition in X509_NAME_cmp */
- if (X509_NAME_entry_count(cert_subject) != in_entries) {
- SPICE_DEBUG("subject mismatch: #entries cert=%d, input=%d",
- X509_NAME_entry_count(cert_subject), in_entries);
- return 0;
- }
-
- ret = X509_NAME_cmp(cert_subject, verify->in_subject);
-
- if (ret == 0)
- SPICE_DEBUG("subjects match");
- else
- SPICE_DEBUG("subjects mismatch");
-
- return !ret;
-}
-
-static int openssl_verify(int preverify_ok, X509_STORE_CTX *ctx)
-{
- int depth;
- SpiceOpenSSLVerify *v;
- SSL *ssl;
- X509* cert;
-
- ssl = (SSL*)X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
- v = (SpiceOpenSSLVerify*)SSL_get_app_data(ssl);
-
- depth = X509_STORE_CTX_get_error_depth(ctx);
- if (depth > 0) {
- if (!preverify_ok) {
- SPICE_DEBUG("openssl verify failed at depth=%d", depth);
- v->all_preverify_ok = 0;
- return 0;
- } else
- return 1;
- }
-
- /* depth == 0 */
- cert = X509_STORE_CTX_get_current_cert(ctx);
- if (!cert) {
- SPICE_DEBUG("failed to get server certificate");
- return 0;
- }
-
- if (v->verifyop & SPICE_SSL_VERIFY_OP_PUBKEY &&
- verify_pubkey(cert, v->pubkey, v->pubkey_size))
- return 1;
-
- if (!v->all_preverify_ok || !preverify_ok)
- return 0;
-
- if (v->verifyop & SPICE_SSL_VERIFY_OP_HOSTNAME &&
- verify_hostname(cert, v->hostname))
- return 1;
-
- if (v->verifyop & SPICE_SSL_VERIFY_OP_SUBJECT &&
- verify_subject(cert, v))
- return 1;
-
- return 0;
-}
-
-SpiceOpenSSLVerify* spice_openssl_verify_new(SSL *ssl, SPICE_SSL_VERIFY_OP verifyop,
- const char *hostname,
- const char *pubkey, size_t pubkey_size,
- const char *subject)
-{
- SpiceOpenSSLVerify *v;
-
- if (!verifyop)
- return NULL;
-
- v = spice_new0(SpiceOpenSSLVerify, 1);
-
- v->ssl = ssl;
- v->verifyop = verifyop;
- v->hostname = spice_strdup(hostname);
- v->pubkey = (char*)spice_memdup(pubkey, pubkey_size);
- v->pubkey_size = pubkey_size;
- v->subject = spice_strdup(subject);
-
- v->all_preverify_ok = 1;
-
- SSL_set_app_data(ssl, v);
- SSL_set_verify(ssl,
- SSL_VERIFY_PEER, openssl_verify);
-
- return v;
-}
-
-void spice_openssl_verify_free(SpiceOpenSSLVerify* verify)
-{
- if (!verify)
- return;
-
- free(verify->pubkey);
- free(verify->subject);
- free(verify->hostname);
-
- if (verify->in_subject)
- X509_NAME_free(verify->in_subject);
-
- if (verify->ssl)
- SSL_set_app_data(verify->ssl, NULL);
- free(verify);
-}
diff --git a/common/ssl_verify.h b/common/ssl_verify.h
deleted file mode 100644
index 067762b..0000000
--- a/common/ssl_verify.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2011 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef SSL_VERIFY_H
-#define SSL_VERIFY_H
-
-#if defined(WIN32) && !defined(__MINGW32__)
-#include <windows.h>
-#include <wincrypt.h>
-#endif
-
-#include <openssl/rsa.h>
-#include <openssl/evp.h>
-#include <openssl/x509.h>
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#undef X509_NAME
-#include <openssl/x509v3.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
- SPICE_SSL_VERIFY_OP_NONE = 0,
- SPICE_SSL_VERIFY_OP_PUBKEY = (1 << 0),
- SPICE_SSL_VERIFY_OP_HOSTNAME = (1 << 1),
- SPICE_SSL_VERIFY_OP_SUBJECT = (1 << 2),
-} SPICE_SSL_VERIFY_OP;
-
-typedef struct {
- SSL *ssl;
- SPICE_SSL_VERIFY_OP verifyop;
- int all_preverify_ok;
- char *hostname;
- char *pubkey;
- size_t pubkey_size;
- char *subject;
- X509_NAME *in_subject;
-} SpiceOpenSSLVerify;
-
-SpiceOpenSSLVerify* spice_openssl_verify_new(SSL *ssl, SPICE_SSL_VERIFY_OP verifyop,
- const char *hostname,
- const char *pubkey, size_t pubkey_size,
- const char *subject);
-void spice_openssl_verify_free(SpiceOpenSSLVerify* verify);
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-#endif // SSL_VERIFY_H
diff --git a/common/sw_canvas.c b/common/sw_canvas.c
deleted file mode 100644
index 8eabc89..0000000
--- a/common/sw_canvas.c
+++ /dev/null
@@ -1,1327 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#ifdef __MINGW32__
-#undef HAVE_STDLIB_H
-#endif
-#include <config.h>
-#endif
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This file shouldn't be compiled directly"
-#endif
-
-#include <math.h>
-#include "sw_canvas.h"
-#define CANVAS_USE_PIXMAN
-#define CANVAS_SINGLE_INSTANCE
-#include "canvas_base.c"
-#include "rect.h"
-#include "region.h"
-#include "pixman_utils.h"
-
-typedef struct SwCanvas SwCanvas;
-
-struct SwCanvas {
- CanvasBase base;
- uint32_t *private_data;
- int private_data_size;
- pixman_image_t *image;
-};
-
-static pixman_image_t *canvas_get_pixman_brush(SwCanvas *canvas,
- SpiceBrush *brush)
-{
- switch (brush->type) {
- case SPICE_BRUSH_TYPE_SOLID: {
- uint32_t color = brush->u.color;
- pixman_color_t c;
-
- c.blue = ((color & canvas->base.color_mask) * 0xffff) / canvas->base.color_mask;
- color >>= canvas->base.color_shift;
- c.green = ((color & canvas->base.color_mask) * 0xffff) / canvas->base.color_mask;
- color >>= canvas->base.color_shift;
- c.red = ((color & canvas->base.color_mask) * 0xffff) / canvas->base.color_mask;
- c.alpha = 0xffff;
-
- return pixman_image_create_solid_fill(&c);
- }
- case SPICE_BRUSH_TYPE_PATTERN: {
- SwCanvas *surface_canvas;
- pixman_image_t* surface;
- pixman_transform_t t;
-
- surface_canvas = (SwCanvas *)canvas_get_surface(&canvas->base, brush->u.pattern.pat);
- if (surface_canvas) {
- surface = surface_canvas->image;
- surface = pixman_image_ref(surface);
- } else {
- surface = canvas_get_image(&canvas->base, brush->u.pattern.pat, FALSE);
- }
- pixman_transform_init_translate(&t,
- pixman_int_to_fixed(-brush->u.pattern.pos.x),
- pixman_int_to_fixed(-brush->u.pattern.pos.y));
- pixman_image_set_transform(surface, &t);
- pixman_image_set_repeat(surface, PIXMAN_REPEAT_NORMAL);
- return surface;
- }
- case SPICE_BRUSH_TYPE_NONE:
- return NULL;
- default:
- CANVAS_ERROR("invalid brush type");
- }
-}
-
-static pixman_image_t *get_image(SpiceCanvas *canvas)
-{
- SwCanvas *sw_canvas = (SwCanvas *)canvas;
-
- pixman_image_ref(sw_canvas->image);
-
- return sw_canvas->image;
-}
-
-static void copy_region(SpiceCanvas *spice_canvas,
- pixman_region32_t *dest_region,
- int dx, int dy)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_box32_t *dest_rects;
- int n_rects;
- int i, j, end_line;
-
- dest_rects = pixman_region32_rectangles(dest_region, &n_rects);
-
- if (dy > 0) {
- if (dx >= 0) {
- /* south-east: copy x and y in reverse order */
- for (i = n_rects - 1; i >= 0; i--) {
- spice_pixman_copy_rect(canvas->image,
- dest_rects[i].x1 - dx, dest_rects[i].y1 - dy,
- dest_rects[i].x2 - dest_rects[i].x1,
- dest_rects[i].y2 - dest_rects[i].y1,
- dest_rects[i].x1, dest_rects[i].y1);
- }
- } else {
- /* south-west: Copy y in reverse order, but x in forward order */
- i = n_rects - 1;
-
- while (i >= 0) {
- /* Copy all rects with same y in forward order */
- for (end_line = i - 1;
- end_line >= 0 && dest_rects[end_line].y1 == dest_rects[i].y1;
- end_line--) {
- }
- for (j = end_line + 1; j <= i; j++) {
- spice_pixman_copy_rect(canvas->image,
- dest_rects[j].x1 - dx, dest_rects[j].y1 - dy,
- dest_rects[j].x2 - dest_rects[j].x1,
- dest_rects[j].y2 - dest_rects[j].y1,
- dest_rects[j].x1, dest_rects[j].y1);
- }
- i = end_line;
- }
- }
- } else {
- if (dx > 0) {
- /* north-east: copy y in forward order, but x in reverse order */
- i = 0;
-
- while (i < n_rects) {
- /* Copy all rects with same y in reverse order */
- for (end_line = i;
- end_line < n_rects && dest_rects[end_line].y1 == dest_rects[i].y1;
- end_line++) {
- }
- for (j = end_line - 1; j >= i; j--) {
- spice_pixman_copy_rect(canvas->image,
- dest_rects[j].x1 - dx, dest_rects[j].y1 - dy,
- dest_rects[j].x2 - dest_rects[j].x1,
- dest_rects[j].y2 - dest_rects[j].y1,
- dest_rects[j].x1, dest_rects[j].y1);
- }
- i = end_line;
- }
- } else {
- /* north-west: Copy x and y in forward order */
- for (i = 0; i < n_rects; i++) {
- spice_pixman_copy_rect(canvas->image,
- dest_rects[i].x1 - dx, dest_rects[i].y1 - dy,
- dest_rects[i].x2 - dest_rects[i].x1,
- dest_rects[i].y2 - dest_rects[i].y1,
- dest_rects[i].x1, dest_rects[i].y1);
- }
- }
- }
-}
-
-static void fill_solid_spans(SpiceCanvas *spice_canvas,
- SpicePoint *points,
- int *widths,
- int n_spans,
- uint32_t color)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- int i;
-
- for (i = 0; i < n_spans; i++) {
- spice_pixman_fill_rect(canvas->image,
- points[i].x, points[i].y,
- widths[i],
- 1,
- color);
- }
-}
-
-static void fill_solid_rects(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- uint32_t color)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- int i;
-
- for (i = 0; i < n_rects; i++) {
- spice_pixman_fill_rect(canvas->image,
- rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1,
- rects[i].y2 - rects[i].y1,
- color);
- }
-}
-
-static void fill_solid_rects_rop(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- uint32_t color,
- SpiceROP rop)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- int i;
-
- for (i = 0; i < n_rects; i++) {
- spice_pixman_fill_rect_rop(canvas->image,
- rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1,
- rects[i].y2 - rects[i].y1,
- color, rop);
- }
-}
-
-static void __fill_tiled_rects(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- pixman_image_t *tile,
- int offset_x, int offset_y)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- int i;
-
- for (i = 0; i < n_rects; i++) {
- spice_pixman_tile_rect(canvas->image,
- rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1,
- rects[i].y2 - rects[i].y1,
- tile, offset_x, offset_y);
- }
-}
-
-static void fill_tiled_rects(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- pixman_image_t *tile,
- int offset_x, int offset_y)
-{
- __fill_tiled_rects(spice_canvas, rects, n_rects, tile, offset_x, offset_y);
-}
-
-static void fill_tiled_rects_from_surface(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- SpiceCanvas *surface_canvas,
- int offset_x, int offset_y)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __fill_tiled_rects(spice_canvas, rects, n_rects, sw_surface_canvas->image, offset_x,
- offset_y);
-}
-
-static void __fill_tiled_rects_rop(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- pixman_image_t *tile,
- int offset_x, int offset_y,
- SpiceROP rop)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- int i;
-
- for (i = 0; i < n_rects; i++) {
- spice_pixman_tile_rect_rop(canvas->image,
- rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1,
- rects[i].y2 - rects[i].y1,
- tile, offset_x, offset_y,
- rop);
- }
-}
-static void fill_tiled_rects_rop(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- pixman_image_t *tile,
- int offset_x, int offset_y,
- SpiceROP rop)
-{
- __fill_tiled_rects_rop(spice_canvas, rects, n_rects, tile, offset_x, offset_y, rop);
-}
-
-static void fill_tiled_rects_rop_from_surface(SpiceCanvas *spice_canvas,
- pixman_box32_t *rects,
- int n_rects,
- SpiceCanvas *surface_canvas,
- int offset_x, int offset_y,
- SpiceROP rop)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __fill_tiled_rects_rop(spice_canvas, rects, n_rects, sw_surface_canvas->image, offset_x,
- offset_y, rop);
-}
-
-/* Some pixman implementations of OP_OVER on xRGB32 sets
- the high bit to 0xff (which is the right value if the
- destination was ARGB32, and it should be ignored for
- xRGB32. However, this fills our alpha bits with
- data that is not wanted or expected by windows, and its
- causing us to send rgba images rather than rgb images to
- the client. So, we manually clear these bytes. */
-static void clear_dest_alpha(pixman_image_t *dest,
- int x, int y,
- int width, int height)
-{
- uint32_t *data;
- int stride;
- int w, h;
-
- w = pixman_image_get_width(dest);
- h = pixman_image_get_height(dest);
-
- if (x + width <= 0 || x >= w ||
- y + height <= 0 || y >= h ||
- width == 0 || height == 0) {
- return;
- }
-
- if (x < 0) {
- width += x;
- x = 0;
- }
- if (x + width > w) {
- width = w - x;
- }
-
- if (y < 0) {
- height += y;
- y = 0;
- }
- if (y + height > h) {
- height = h - y;
- }
-
- stride = pixman_image_get_stride(dest);
- data = (uint32_t *) (
- (uint8_t *)pixman_image_get_data(dest) + y * stride + 4 * x);
-
- if ((*data & 0xff000000U) == 0xff000000U) {
- spice_pixman_fill_rect_rop(dest,
- x, y, width, height,
- 0x00ffffff, SPICE_ROP_AND);
- }
-}
-
-static void __blit_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_box32_t *rects;
- int n_rects, i;
-
- rects = pixman_region32_rectangles(region, &n_rects);
-
- for (i = 0; i < n_rects; i++) {
- int src_x, src_y, dest_x, dest_y, width, height;
-
- dest_x = rects[i].x1;
- dest_y = rects[i].y1;
- width = rects[i].x2 - rects[i].x1;
- height = rects[i].y2 - rects[i].y1;
-
- src_x = rects[i].x1 - offset_x;
- src_y = rects[i].y1 - offset_y;
-
- spice_pixman_blit(canvas->image,
- src_image,
- src_x, src_y,
- dest_x, dest_y,
- width, height);
- }
-}
-
-static void blit_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y)
-{
- __blit_image(spice_canvas, region, src_image, offset_x, offset_y);
-}
-
-static void blit_image_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- SpiceCanvas *surface_canvas,
- int offset_x, int offset_y)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __blit_image(spice_canvas, region, sw_surface_canvas->image, offset_x, offset_y);
-}
-
-static void __blit_image_rop(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y,
- SpiceROP rop)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_box32_t *rects;
- int n_rects, i;
-
- rects = pixman_region32_rectangles(region, &n_rects);
-
- for (i = 0; i < n_rects; i++) {
- int src_x, src_y, dest_x, dest_y, width, height;
-
- dest_x = rects[i].x1;
- dest_y = rects[i].y1;
- width = rects[i].x2 - rects[i].x1;
- height = rects[i].y2 - rects[i].y1;
-
- src_x = rects[i].x1 - offset_x;
- src_y = rects[i].y1 - offset_y;
-
- spice_pixman_blit_rop(canvas->image,
- src_image,
- src_x, src_y,
- dest_x, dest_y,
- width, height, rop);
- }
-}
-
-static void blit_image_rop(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y,
- SpiceROP rop)
-{
- __blit_image_rop(spice_canvas, region, src_image, offset_x, offset_y, rop);
-}
-
-static void blit_image_rop_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- SpiceCanvas *surface_canvas,
- int offset_x, int offset_y,
- SpiceROP rop)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __blit_image_rop(spice_canvas, region, sw_surface_canvas->image, offset_x, offset_y, rop);
-}
-
-
-
-static void __scale_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_transform_t transform;
- pixman_fixed_t fsx, fsy;
-
- fsx = ((pixman_fixed_48_16_t) src_width * 65536) / dest_width;
- fsy = ((pixman_fixed_48_16_t) src_height * 65536) / dest_height;
-
- pixman_image_set_clip_region32(canvas->image, region);
-
- pixman_transform_init_scale(&transform, fsx, fsy);
- pixman_transform_translate(&transform, NULL,
- pixman_int_to_fixed (src_x),
- pixman_int_to_fixed (src_y));
-
- pixman_image_set_transform(src, &transform);
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
- ASSERT(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
- scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
- pixman_image_set_filter(src,
- (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
- PIXMAN_FILTER_NEAREST : PIXMAN_FILTER_GOOD,
- NULL, 0);
-
- pixman_image_composite32(PIXMAN_OP_SRC,
- src, NULL, canvas->image,
- 0, 0, /* src */
- 0, 0, /* mask */
- dest_x, dest_y, /* dst */
- dest_width, dest_height);
-
- pixman_transform_init_identity(&transform);
- pixman_image_set_transform(src, &transform);
-
- pixman_image_set_clip_region32(canvas->image, NULL);
-}
-
-static void scale_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode)
-{
- __scale_image(spice_canvas, region, src, src_x, src_y, src_width, src_height, dest_x, dest_y,
- dest_width,dest_height,scale_mode);
-}
-
-static void scale_image_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- SpiceCanvas *surface_canvas,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __scale_image(spice_canvas, region, sw_surface_canvas->image, src_x, src_y, src_width,
- src_height, dest_x, dest_y, dest_width,dest_height,scale_mode);
-}
-
-static void __scale_image_rop(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode, SpiceROP rop)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_transform_t transform;
- pixman_image_t *scaled;
- pixman_box32_t *rects;
- int n_rects, i;
- pixman_fixed_t fsx, fsy;
-
- fsx = ((pixman_fixed_48_16_t) src_width * 65536) / dest_width;
- fsy = ((pixman_fixed_48_16_t) src_height * 65536) / dest_height;
-
- scaled = pixman_image_create_bits(spice_pixman_image_get_format(src),
- dest_width,
- dest_height,
- NULL, 0);
-
- pixman_region32_translate(region, -dest_x, -dest_y);
- pixman_image_set_clip_region32(scaled, region);
-
- pixman_transform_init_scale(&transform, fsx, fsy);
- pixman_transform_translate(&transform, NULL,
- pixman_int_to_fixed (src_x),
- pixman_int_to_fixed (src_y));
-
- pixman_image_set_transform(src, &transform);
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
- ASSERT(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
- scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
- pixman_image_set_filter(src,
- (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
- PIXMAN_FILTER_NEAREST : PIXMAN_FILTER_GOOD,
- NULL, 0);
-
- pixman_image_composite32(PIXMAN_OP_SRC,
- src, NULL, scaled,
- 0, 0, /* src */
- 0, 0, /* mask */
- 0, 0, /* dst */
- dest_width,
- dest_height);
-
- pixman_transform_init_identity(&transform);
- pixman_image_set_transform(src, &transform);
-
- /* Translate back */
- pixman_region32_translate(region, dest_x, dest_y);
-
- rects = pixman_region32_rectangles(region, &n_rects);
-
- for (i = 0; i < n_rects; i++) {
- spice_pixman_blit_rop(canvas->image,
- scaled,
- rects[i].x1 - dest_x,
- rects[i].y1 - dest_y,
- rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1,
- rects[i].y2 - rects[i].y1,
- rop);
- }
-
- pixman_image_unref(scaled);
-}
-
-static void scale_image_rop(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode, SpiceROP rop)
-{
- __scale_image_rop(spice_canvas, region, src, src_x, src_y, src_width, src_height, dest_x,
- dest_y, dest_width, dest_height, scale_mode, rop);
-}
-
-static void scale_image_rop_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- SpiceCanvas *surface_canvas,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode, SpiceROP rop)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __scale_image_rop(spice_canvas, region, sw_surface_canvas->image, src_x, src_y, src_width,
- src_height, dest_x, dest_y, dest_width, dest_height, scale_mode, rop);
-}
-
-static pixman_image_t *canvas_get_as_surface(SwCanvas *canvas,
- int with_alpha)
-{
- pixman_image_t *target;
-
- if (with_alpha &&
- canvas->base.format == SPICE_SURFACE_FMT_32_xRGB) {
- target = pixman_image_create_bits(PIXMAN_a8r8g8b8,
- pixman_image_get_width(canvas->image),
- pixman_image_get_height(canvas->image),
- pixman_image_get_data(canvas->image),
- pixman_image_get_stride(canvas->image));
- } else {
- target = pixman_image_ref(canvas->image);
- }
-
- return target;
-}
-
-static void __blend_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- int overall_alpha)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_image_t *mask, *dest;
-
- dest = canvas_get_as_surface(canvas, dest_has_alpha);
-
- pixman_image_set_clip_region32(dest, region);
-
- mask = NULL;
- if (overall_alpha != 0xff) {
- pixman_color_t color = { 0 };
- color.alpha = overall_alpha * 0x101;
- mask = pixman_image_create_solid_fill(&color);
- }
-
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
-
- pixman_image_composite32(PIXMAN_OP_OVER,
- src, mask, dest,
- src_x, src_y, /* src */
- 0, 0, /* mask */
- dest_x, dest_y, /* dst */
- width,
- height);
-
- if (canvas->base.format == SPICE_SURFACE_FMT_32_xRGB &&
- !dest_has_alpha) {
- clear_dest_alpha(dest, dest_x, dest_y, width, height);
- }
-
- if (mask) {
- pixman_image_unref(mask);
- }
-
- pixman_image_set_clip_region32(dest, NULL);
- pixman_image_unref(dest);
-}
-
-static void blend_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- pixman_image_t *src,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- int overall_alpha)
-{
- __blend_image(spice_canvas, region, dest_has_alpha, src, src_x, src_y,
- dest_x, dest_y, width, height,
- overall_alpha);
-}
-
-static void blend_image_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- SpiceCanvas *surface_canvas,
- int src_has_alpha,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height,
- int overall_alpha)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- pixman_image_t *src;
-
- src = canvas_get_as_surface(sw_surface_canvas, src_has_alpha);
- __blend_image(spice_canvas, region, dest_has_alpha,
- src, src_x, src_y,
- dest_x, dest_y,
- width, height, overall_alpha);
- pixman_image_unref(src);
-}
-
-static void __blend_scale_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode,
- int overall_alpha)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_transform_t transform;
- pixman_image_t *mask, *dest;
- pixman_fixed_t fsx, fsy;
-
- fsx = ((pixman_fixed_48_16_t) src_width * 65536) / dest_width;
- fsy = ((pixman_fixed_48_16_t) src_height * 65536) / dest_height;
-
- dest = canvas_get_as_surface(canvas, dest_has_alpha);
-
- pixman_image_set_clip_region32(dest, region);
-
- pixman_transform_init_scale(&transform, fsx, fsy);
- pixman_transform_translate(&transform, NULL,
- pixman_int_to_fixed (src_x),
- pixman_int_to_fixed (src_y));
-
- mask = NULL;
- if (overall_alpha != 0xff) {
- pixman_color_t color = { 0 };
- color.alpha = overall_alpha * 0x101;
- mask = pixman_image_create_solid_fill(&color);
- }
-
- pixman_image_set_transform(src, &transform);
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
- ASSERT(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
- scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
- pixman_image_set_filter(src,
- (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
- PIXMAN_FILTER_NEAREST : PIXMAN_FILTER_GOOD,
- NULL, 0);
-
- pixman_image_composite32(PIXMAN_OP_OVER,
- src, mask, dest,
- 0, 0, /* src */
- 0, 0, /* mask */
- dest_x, dest_y, /* dst */
- dest_width, dest_height);
-
- if (canvas->base.format == SPICE_SURFACE_FMT_32_xRGB &&
- !dest_has_alpha) {
- clear_dest_alpha(dest, dest_x, dest_y, dest_width, dest_height);
- }
-
- pixman_transform_init_identity(&transform);
- pixman_image_set_transform(src, &transform);
-
- if (mask) {
- pixman_image_unref(mask);
- }
-
- pixman_image_set_clip_region32(dest, NULL);
- pixman_image_unref(dest);
-}
-
-static void blend_scale_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode,
- int overall_alpha)
-{
- __blend_scale_image(spice_canvas, region, dest_has_alpha,
- src, src_x, src_y, src_width, src_height,
- dest_x, dest_y, dest_width, dest_height,
- scale_mode, overall_alpha);
-}
-
-static void blend_scale_image_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- int dest_has_alpha,
- SpiceCanvas *surface_canvas,
- int src_has_alpha,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- int scale_mode,
- int overall_alpha)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- pixman_image_t *src;
-
- src = canvas_get_as_surface(sw_surface_canvas, src_has_alpha);
- __blend_scale_image(spice_canvas, region, dest_has_alpha, src, src_x, src_y, src_width,
- src_height, dest_x, dest_y, dest_width, dest_height, scale_mode,
- overall_alpha);
- pixman_image_unref(src);
-}
-
-static void __colorkey_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y,
- uint32_t transparent_color)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_box32_t *rects;
- int n_rects, i;
-
- rects = pixman_region32_rectangles(region, &n_rects);
-
- for (i = 0; i < n_rects; i++) {
- int src_x, src_y, dest_x, dest_y, width, height;
-
- dest_x = rects[i].x1;
- dest_y = rects[i].y1;
- width = rects[i].x2 - rects[i].x1;
- height = rects[i].y2 - rects[i].y1;
-
- src_x = rects[i].x1 - offset_x;
- src_y = rects[i].y1 - offset_y;
-
- spice_pixman_blit_colorkey(canvas->image,
- src_image,
- src_x, src_y,
- dest_x, dest_y,
- width, height,
- transparent_color);
- }
-}
-
-static void colorkey_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src_image,
- int offset_x, int offset_y,
- uint32_t transparent_color)
-{
- __colorkey_image(spice_canvas, region, src_image, offset_x, offset_y, transparent_color);
-}
-
-static void colorkey_image_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- SpiceCanvas *surface_canvas,
- int offset_x, int offset_y,
- uint32_t transparent_color)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __colorkey_image(spice_canvas, region, sw_surface_canvas->image, offset_x, offset_y,
- transparent_color);
-}
-
-static void __colorkey_scale_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- uint32_t transparent_color)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_transform_t transform;
- pixman_image_t *scaled;
- pixman_box32_t *rects;
- int n_rects, i;
- pixman_fixed_t fsx, fsy;
-
- fsx = ((pixman_fixed_48_16_t) src_width * 65536) / dest_width;
- fsy = ((pixman_fixed_48_16_t) src_height * 65536) / dest_height;
-
- scaled = pixman_image_create_bits(spice_pixman_image_get_format (src),
- dest_width,
- dest_height,
- NULL, 0);
-
- pixman_region32_translate(region, -dest_x, -dest_y);
- pixman_image_set_clip_region32(scaled, region);
-
- pixman_transform_init_scale(&transform, fsx, fsy);
- pixman_transform_translate(&transform, NULL,
- pixman_int_to_fixed (src_x),
- pixman_int_to_fixed (src_y));
-
- pixman_image_set_transform(src, &transform);
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
- pixman_image_set_filter(src,
- PIXMAN_FILTER_NEAREST,
- NULL, 0);
-
- pixman_image_composite32(PIXMAN_OP_SRC,
- src, NULL, scaled,
- 0, 0, /* src */
- 0, 0, /* mask */
- 0, 0, /* dst */
- dest_width,
- dest_height);
-
- pixman_transform_init_identity(&transform);
- pixman_image_set_transform(src, &transform);
-
- /* Translate back */
- pixman_region32_translate(region, dest_x, dest_y);
-
- rects = pixman_region32_rectangles(region, &n_rects);
-
- for (i = 0; i < n_rects; i++) {
- spice_pixman_blit_colorkey(canvas->image,
- scaled,
- rects[i].x1 - dest_x,
- rects[i].y1 - dest_y,
- rects[i].x1, rects[i].y1,
- rects[i].x2 - rects[i].x1,
- rects[i].y2 - rects[i].y1,
- transparent_color);
- }
-
- pixman_image_unref(scaled);
-}
-
-static void colorkey_scale_image(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- pixman_image_t *src,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- uint32_t transparent_color)
-{
- __colorkey_scale_image(spice_canvas, region, src, src_x, src_y, src_width, src_height, dest_x,
- dest_y, dest_width, dest_height, transparent_color);
-}
-
-static void colorkey_scale_image_from_surface(SpiceCanvas *spice_canvas,
- pixman_region32_t *region,
- SpiceCanvas *surface_canvas,
- int src_x, int src_y,
- int src_width, int src_height,
- int dest_x, int dest_y,
- int dest_width, int dest_height,
- uint32_t transparent_color)
-{
- SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
- __colorkey_scale_image(spice_canvas, region, sw_surface_canvas->image, src_x, src_y,
- src_width, src_height, dest_x, dest_y, dest_width, dest_height,
- transparent_color);
-}
-
-static void canvas_put_image(SpiceCanvas *spice_canvas,
-#ifdef WIN32
- HDC dc,
-#endif
- const SpiceRect *dest, const uint8_t *src_data,
- uint32_t src_width, uint32_t src_height, int src_stride,
- const QRegion *clip)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_image_t *src;
- uint32_t dest_width;
- uint32_t dest_height;
- double sx, sy;
- pixman_transform_t transform;
-
- src = pixman_image_create_bits(PIXMAN_x8r8g8b8,
- src_width,
- src_height,
- (uint32_t*)src_data,
- src_stride);
-
-
- if (clip) {
- pixman_image_set_clip_region32 (canvas->image, (pixman_region32_t *)clip);
- }
-
- dest_width = dest->right - dest->left;
- dest_height = dest->bottom - dest->top;
-
- if (dest_width != src_width || dest_height != src_height) {
- sx = (double)(src_width) / (dest_width);
- sy = (double)(src_height) / (dest_height);
-
- pixman_transform_init_scale(&transform,
- pixman_double_to_fixed(sx),
- pixman_double_to_fixed(sy));
- pixman_image_set_transform(src, &transform);
- pixman_image_set_filter(src,
- PIXMAN_FILTER_NEAREST,
- NULL, 0);
- }
-
- pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
-
- pixman_image_composite32(PIXMAN_OP_SRC,
- src, NULL, canvas->image,
- 0, 0, /* src */
- 0, 0, /* mask */
- dest->left, dest->top, /* dst */
- dest_width, dest_height);
-
-
- if (clip) {
- pixman_image_set_clip_region32(canvas->image, NULL);
- }
- pixman_image_unref(src);
-}
-
-
-static void canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox,
- SpiceClip *clip, SpiceText *text)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_region32_t dest_region;
- pixman_image_t *str_mask, *brush;
- SpiceString *str;
- SpicePoint pos;
- int depth;
-
- pixman_region32_init_rect(&dest_region,
- bbox->left, bbox->top,
- bbox->right - bbox->left,
- bbox->bottom - bbox->top);
-
- canvas_clip_pixman(&canvas->base, &dest_region, clip);
-
- if (!pixman_region32_not_empty(&dest_region)) {
- touch_brush(&canvas->base, &text->fore_brush);
- touch_brush(&canvas->base, &text->back_brush);
- pixman_region32_fini(&dest_region);
- return;
- }
-
- if (!rect_is_empty(&text->back_area)) {
- pixman_region32_t back_region;
-
- /* Nothing else makes sense for text and we should deprecate it
- * and actually it means OVER really */
- ASSERT(text->fore_mode == SPICE_ROPD_OP_PUT);
-
- pixman_region32_init_rect(&back_region,
- text->back_area.left,
- text->back_area.top,
- text->back_area.right - text->back_area.left,
- text->back_area.bottom - text->back_area.top);
-
- pixman_region32_intersect(&back_region, &back_region, &dest_region);
-
- if (pixman_region32_not_empty(&back_region)) {
- draw_brush(spice_canvas, &back_region, &text->back_brush, SPICE_ROP_COPY);
- }
-
- pixman_region32_fini(&back_region);
- }
- str = (SpiceString *)SPICE_GET_ADDRESS(text->str);
-
- if (str->flags & SPICE_STRING_FLAGS_RASTER_A1) {
- depth = 1;
- } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A4) {
- depth = 4;
- } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
- WARN("untested path A8 glyphs");
- depth = 8;
- } else {
- WARN("unsupported path vector glyphs");
- pixman_region32_fini (&dest_region);
- return;
- }
-
- brush = canvas_get_pixman_brush(canvas, &text->fore_brush);
-
- str_mask = canvas_get_str_mask(&canvas->base, str, depth, &pos);
- if (brush) {
- pixman_image_set_clip_region32(canvas->image, &dest_region);
-
- pixman_image_composite32(PIXMAN_OP_OVER,
- brush,
- str_mask,
- canvas->image,
- 0, 0,
- 0, 0,
- pos.x, pos.y,
- pixman_image_get_width(str_mask),
- pixman_image_get_height(str_mask));
- if (canvas->base.format == SPICE_SURFACE_FMT_32_xRGB) {
- clear_dest_alpha(canvas->image, pos.x, pos.y,
- pixman_image_get_width(str_mask),
- pixman_image_get_height(str_mask));
- }
- pixman_image_unref(brush);
-
- pixman_image_set_clip_region32(canvas->image, NULL);
- }
- pixman_image_unref(str_mask);
- pixman_region32_fini(&dest_region);
-}
-
-static void canvas_read_bits(SpiceCanvas *spice_canvas, uint8_t *dest,
- int dest_stride, const SpiceRect *area)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- pixman_image_t* surface;
- uint8_t *src;
- int src_stride;
- uint8_t *dest_end;
- int bpp;
-
- ASSERT(canvas && area);
-
- surface = canvas->image;
-
- bpp = spice_pixman_image_get_bpp(surface) / 8;
-
- src_stride = pixman_image_get_stride(surface);
- src = (uint8_t *)pixman_image_get_data(surface) +
- area->top * src_stride + area->left * bpp;
- dest_end = dest + (area->bottom - area->top) * dest_stride;
- for (; dest != dest_end; dest += dest_stride, src += src_stride) {
- memcpy(dest, src, (area->right - area->left) * bpp);
- }
-}
-
-static void canvas_clear(SpiceCanvas *spice_canvas)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- spice_pixman_fill_rect(canvas->image,
- 0, 0,
- pixman_image_get_width(canvas->image),
- pixman_image_get_height(canvas->image),
- 0);
-}
-
-static void canvas_destroy(SpiceCanvas *spice_canvas)
-{
- SwCanvas *canvas = (SwCanvas *)spice_canvas;
- if (!canvas) {
- return;
- }
- pixman_image_unref(canvas->image);
- canvas_base_destroy(&canvas->base);
- free(canvas->private_data);
- free(canvas);
-}
-
-static int need_init = 1;
-static SpiceCanvasOps sw_canvas_ops;
-
-static SpiceCanvas *canvas_create_common(pixman_image_t *image,
- uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- )
-{
- SwCanvas *canvas;
-
- if (need_init) {
- return NULL;
- }
- spice_pixman_image_set_format(image,
- spice_surface_format_to_pixman (format));
-
- canvas = spice_new0(SwCanvas, 1);
- canvas_base_init(&canvas->base, &sw_canvas_ops,
- pixman_image_get_width (image),
- pixman_image_get_height (image),
- format
-#ifdef SW_CANVAS_CACHE
- , bits_cache
- , palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , bits_cache
-#endif
- , surfaces
- , glz_decoder
- , jpeg_decoder
- , zlib_decoder
- );
- canvas->private_data = NULL;
- canvas->private_data_size = 0;
-
- canvas->image = image;
-
- return (SpiceCanvas *)canvas;
-}
-
-SpiceCanvas *canvas_create(int width, int height, uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- )
-{
- pixman_image_t *image;
-
- image = pixman_image_create_bits(spice_surface_format_to_pixman (format),
- width, height, NULL, 0);
-
- return canvas_create_common(image, format
-#ifdef SW_CANVAS_CACHE
- , bits_cache
- , palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , bits_cache
-#endif
- , surfaces
- , glz_decoder
- , jpeg_decoder
- , zlib_decoder
- );
-}
-
-SpiceCanvas *canvas_create_for_data(int width, int height, uint32_t format,
- uint8_t *data, int stride
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- )
-{
- pixman_image_t *image;
-
- image = pixman_image_create_bits(spice_surface_format_to_pixman (format),
- width, height, (uint32_t *)data, stride);
-
- return canvas_create_common(image, format
-#ifdef SW_CANVAS_CACHE
- , bits_cache
- , palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , bits_cache
-#endif
- , surfaces
- , glz_decoder
- , jpeg_decoder
- , zlib_decoder
- );
-}
-
-void sw_canvas_init(void) //unsafe global function
-{
- if (!need_init) {
- return;
- }
- need_init = 0;
-
- canvas_base_init_ops(&sw_canvas_ops);
- sw_canvas_ops.draw_text = canvas_draw_text;
- sw_canvas_ops.put_image = canvas_put_image;
- sw_canvas_ops.clear = canvas_clear;
- sw_canvas_ops.read_bits = canvas_read_bits;
- sw_canvas_ops.destroy = canvas_destroy;
-
- sw_canvas_ops.fill_solid_spans = fill_solid_spans;
- sw_canvas_ops.fill_solid_rects = fill_solid_rects;
- sw_canvas_ops.fill_solid_rects_rop = fill_solid_rects_rop;
- sw_canvas_ops.fill_tiled_rects = fill_tiled_rects;
- sw_canvas_ops.fill_tiled_rects_from_surface = fill_tiled_rects_from_surface;
- sw_canvas_ops.fill_tiled_rects_rop = fill_tiled_rects_rop;
- sw_canvas_ops.fill_tiled_rects_rop_from_surface = fill_tiled_rects_rop_from_surface;
- sw_canvas_ops.blit_image = blit_image;
- sw_canvas_ops.blit_image_from_surface = blit_image_from_surface;
- sw_canvas_ops.blit_image_rop = blit_image_rop;
- sw_canvas_ops.blit_image_rop_from_surface = blit_image_rop_from_surface;
- sw_canvas_ops.scale_image = scale_image;
- sw_canvas_ops.scale_image_from_surface = scale_image_from_surface;
- sw_canvas_ops.scale_image_rop = scale_image_rop;
- sw_canvas_ops.scale_image_rop_from_surface = scale_image_rop_from_surface;
- sw_canvas_ops.blend_image = blend_image;
- sw_canvas_ops.blend_image_from_surface = blend_image_from_surface;
- sw_canvas_ops.blend_scale_image = blend_scale_image;
- sw_canvas_ops.blend_scale_image_from_surface = blend_scale_image_from_surface;
- sw_canvas_ops.colorkey_image = colorkey_image;
- sw_canvas_ops.colorkey_image_from_surface = colorkey_image_from_surface;
- sw_canvas_ops.colorkey_scale_image = colorkey_scale_image;
- sw_canvas_ops.colorkey_scale_image_from_surface = colorkey_scale_image_from_surface;
- sw_canvas_ops.copy_region = copy_region;
- sw_canvas_ops.get_image = get_image;
- rop3_init();
-}
diff --git a/common/sw_canvas.h b/common/sw_canvas.h
deleted file mode 100644
index 8667fcc..0000000
--- a/common/sw_canvas.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- Copyright (C) 2009 Red Hat, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _H__CANVAS
-#define _H__CANVAS
-
-#ifndef SPICE_CANVAS_INTERNAL
-#error "This header shouldn't be included directly"
-#endif
-
-#include <stdint.h>
-
-#include "draw.h"
-#include "pixman_utils.h"
-#include "canvas_base.h"
-#include "region.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-SpiceCanvas *canvas_create(int width, int height, uint32_t format
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- );
-
-SpiceCanvas *canvas_create_for_data(int width, int height, uint32_t format, uint8_t *data, int stride
-#ifdef SW_CANVAS_CACHE
- , SpiceImageCache *bits_cache
- , SpicePaletteCache *palette_cache
-#elif defined(SW_CANVAS_IMAGE_CACHE)
- , SpiceImageCache *bits_cache
-#endif
- , SpiceImageSurfaces *surfaces
- , SpiceGlzDecoder *glz_decoder
- , SpiceJpegDecoder *jpeg_decoder
- , SpiceZlibDecoder *zlib_decoder
- );
-
-
-void sw_canvas_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/common/win/Makefile.am b/common/win/Makefile.am
deleted file mode 100644
index 201691b..0000000
--- a/common/win/Makefile.am
+++ /dev/null
@@ -1 +0,0 @@
-SUBDIRS = my_getopt-1.5
diff --git a/common/win/my_getopt-1.5/ChangeLog b/common/win/my_getopt-1.5/ChangeLog
deleted file mode 100644
index a671fdb..0000000
--- a/common/win/my_getopt-1.5/ChangeLog
+++ /dev/null
@@ -1,22 +0,0 @@
-2006-12-09 Benjamin C. W. Sittler <bsittler@>
-
- * my_getopt.c: add my_getopt_reset to reset the argument parser
-
- * README: updated email address, updated for version 1.5
-
-2002-07-26 Benjamin C. W. Sittler <bsittler at knownow.com>
-
- * README: updated for version 1.4
-
- * my_getopt.c: now we include <sys/types.h> explicitly for those
- systems that narrowly (mis-)interpret ANSI C and POSIX
- (_my_getopt_internal): added an explicit cast to size_t to make
- g++ happy
-
- * getopt.h, my_getopt.h: added extern "C" { ... } for C++
- compilation (thanks to Jeff Lawson <bovine at ud.com> and others)
-
-2001-08-20 Benjamin C. W. Sittler <bsittler at knownow.com>
-
- * getopt.h (getopt_long_only): fixed typo (thanks to Justin Lee
- <justin_lee at ud.com>)
diff --git a/common/win/my_getopt-1.5/LICENSE b/common/win/my_getopt-1.5/LICENSE
deleted file mode 100644
index 2224aba..0000000
--- a/common/win/my_getopt-1.5/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-my_getopt - a command-line argument parser
-Copyright 1997-2001, Benjamin Sittler
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/common/win/my_getopt-1.5/Makefile.am b/common/win/my_getopt-1.5/Makefile.am
deleted file mode 100644
index 73cbf78..0000000
--- a/common/win/my_getopt-1.5/Makefile.am
+++ /dev/null
@@ -1,14 +0,0 @@
-NULL =
-
-EXTRA_DIST = \
- ChangeLog \
- getopt.3 \
- getopt.h \
- getopt.txt \
- LICENSE \
- main.c \
- Makefile \
- my_getopt.c \
- my_getopt.h \
- README \
- $(NULL)
diff --git a/common/win/my_getopt-1.5/Makefile.test b/common/win/my_getopt-1.5/Makefile.test
deleted file mode 100644
index 083cc4a..0000000
--- a/common/win/my_getopt-1.5/Makefile.test
+++ /dev/null
@@ -1,26 +0,0 @@
-all: copy
-
-# Compiler options
-#CCOPTS = -g -O3 -Wall -Werror
-CCOPTS =
-
-# Compiler
-CC = gcc -Wall -Werror
-#CC = cc
-
-# Linker
-LD = $(CC)
-
-# Utility to remove a file
-RM = rm
-
-OBJS = main.o my_getopt.o
-
-copy: $(OBJS)
- $(LD) -o $@ $(OBJS)
-
-clean:
- $(RM) -f copy $(OBJS) *~
-
-%.o: %.c getopt.h my_getopt.h
- $(CC) $(CCOPTS) -o $@ -c $<
diff --git a/common/win/my_getopt-1.5/README b/common/win/my_getopt-1.5/README
deleted file mode 100644
index 3a9afad..0000000
--- a/common/win/my_getopt-1.5/README
+++ /dev/null
@@ -1,140 +0,0 @@
-my_getopt - a command-line argument parser
-Copyright 1997-2006, Benjamin Sittler
-
-The author can be reached by sending email to <bsittler at gmail.com>.
-
-The version of my_getopt in this package (1.5) has a BSD-like license;
-see the file LICENSE for details. Version 1.0 of my_getopt was similar
-to the GPL'ed version of my_getopt included with SMOKE-16 Version 1,
-Release 19990717. SMOKE-16 packages are available from:
-
- http://geocities.com/bsittler/#smoke16
-
-OVERVIEW OF THE ARGUMENT PARSER
-===============================
-
-The getopt(), getopt_long() and getopt_long_only() functions parse
-command line arguments. The argc and argv parameters passed to these
-functions correspond to the argument count and argument list passed to
-your program's main() function at program start-up. Element 0 of the
-argument list conventionally contains the name of your program. Any
-remaining arguments starting with "-" (except for "-" or "--" by
-themselves) are option arguments, some of include option values. This
-family of getopt() functions allows intermixed option and non-option
-arguments anywhere in the argument list, except that "--" by itself
-causes the remaining elements of the argument list to be treated as
-non-option arguments.
-
-[ See the parts of this document labeled "DOCUMENTATION" and
- "WHY RE-INVENT THE WHEEL?" for a more information. ]
-
-FILES
-=====
-
-The following four files constitute the my_getopt package:
-
- LICENSE - license and warranty information for my_getopt
- my_getopt.c - implementation of my getopt replacement
- my_getopt.h - interface for my getopt replacement
- getopt.h - a header file to make my getopt look like GNU getopt
-
-USAGE
-=====
-
-To use my_getopt in your application, include the following line to
-your main program source:
-
- #include "getopt.h"
-
-This line should appear after your standard system header files to
-avoid conflicting with your system's built-in getopt.
-
-Then compile my_getopt.c into my_getopt.o, and link my_getopt.o into
-your application:
-
- $ cc -c my_getopt.c
- $ ld -o app app.o ... my_getopt.o
-
-To avoid conflicting with standard library functions, the function
-names and global variables used by my_getopt all begin with `my_'. To
-ensure compatibility with existing C programs, the `getopt.h' header
-file uses the C preprocessor to redefine names like getopt, optarg,
-optind, and so forth to my_getopt, my_optarg, my_optind, etc.
-
-SAMPLE PROGRAM
-==============
-
-There is also a public-domain sample program:
-
- main.c - main() for a sample program using my_getopt
- Makefile - build script for the sample program (called `copy')
-
-To build and test the sample program:
-
- $ make
- $ ./copy -help
- $ ./copy -version
-
-The sample program bears a slight resemblance to the UNIX `cat'
-utility, but can be used rot13-encode streams, and can redirect output
-to a file.
-
-DOCUMENTATION
-=============
-
-There is not yet any real documentation for my_getopt. For the moment,
-use the Linux manual page for getopt. It has its own copyright and
-license; view the file `getopt.3' in a text editor for more details.
-
- getopt.3 - the manual page for GNU getopt
- getopt.txt - preformatted copy of the manual page for GNU getopt,
- for your convenience
-
-WHY RE-INVENT THE WHEEL?
-========================
-
-I re-implemented getopt, getopt_long, and getopt_long_only because
-there were noticable bugs in several versions of the GNU
-implementations, and because the GNU versions aren't always available
-on some systems (*BSD, for example.) Other systems don't include any
-sort of standard argument parser (Win32 with Microsoft tools, for
-example, has no getopt.)
-
-These should do all the expected Unix- and GNU-style argument
-parsing, including permution, bunching, long options with single or
-double dashes (double dashes are required if you use
-my_getopt_long,) and optional arguments for both long and short
-options. A word with double dashes all by themselves halts argument
-parsing. A required long option argument can be in the same word as
-the option name, separated by '=', or in the next word. An optional
-long option argument must be in the same word as the option name,
-separated by '='.
-
-As with the GNU versions, a '+' prefix to the short option
-specification (or the POSIXLY_CORRECT environment variable) disables
-permution, a '-' prefix to the short option specification returns 1
-for non-options, ':' after a short option indicates a required
-argument, and '::' after a short option specification indicates an
-optional argument (which must appear in the same word.) If you'd like
-to recieve ':' instead of '?' for missing option arguments, prefix the
-short option specification with ':'.
-
-The original intent was to re-implement the documented behavior of
-the GNU versions, but I have found it necessary to emulate some of
-the undocumented behavior as well. Some programs depend on it.
-
-KNOWN BUGS
-==========
-
-The GNU versions support POSIX-style -W "name=value" long
-options. Currently, my_getopt does not support these, because I
-don't have any documentation on them (other than the fact that they
-are enabled by "W;" in the short option specification.) As a
-temporary workaround, my_getopt treats "W;" in the short option
-string identically to "W:".
-
-The GNU versions support internationalized/localized
-messages. Currently, my_getopt does not.
-
-There should be re-entrant versions of all these functions so that
-multiple threads can parse arguments simultaneously.
diff --git a/common/win/my_getopt-1.5/getopt.3 b/common/win/my_getopt-1.5/getopt.3
deleted file mode 100644
index a63fcd8..0000000
--- a/common/win/my_getopt-1.5/getopt.3
+++ /dev/null
@@ -1,288 +0,0 @@
-.\" (c) 1993 by Thomas Koenig (ig25 at rz.uni-karlsruhe.de)
-.\"
-.\" Permission is granted to make and distribute verbatim copies of this
-.\" manual provided the copyright notice and this permission notice are
-.\" preserved on all copies.
-.\"
-.\" Permission is granted to copy and distribute modified versions of this
-.\" manual under the conditions for verbatim copying, provided that the
-.\" entire resulting derived work is distributed under the terms of a
-.\" permission notice identical to this one
-.\"
-.\" Since the Linux kernel and libraries are constantly changing, this
-.\" manual page may be incorrect or out-of-date. The author(s) assume no
-.\" responsibility for errors or omissions, or for damages resulting from
-.\" the use of the information contained herein. The author(s) may not
-.\" have taken the same level of care in the production of this manual,
-.\" which is licensed free of charge, as they might when working
-.\" professionally.
-.\"
-.\" Formatted or processed versions of this manual, if unaccompanied by
-.\" the source, must acknowledge the copyright and authors of this work.
-.\" License.
-.\" Modified Sat Jul 24 19:27:50 1993 by Rik Faith (faith at cs.unc.edu)
-.\" Modified Mon Aug 30 22:02:34 1995 by Jim Van Zandt <jrv at vanzandt.mv.com>
-.\" longindex is a pointer, has_arg can take 3 values, using consistent
-.\" names for optstring and longindex, "\n" in formats fixed. Documenting
-.\" opterr and getopt_long_only. Clarified explanations (borrowing heavily
-.\" from the source code).
-.TH GETOPT 3 "Aug 30, 1995" "GNU" "Linux Programmer's Manual"
-.SH NAME
-getopt \- Parse command line options
-.SH SYNOPSIS
-.nf
-.B #include <unistd.h>
-.sp
-.BI "int getopt(int " argc ", char * const " argv[] ","
-.BI " const char *" optstring ");"
-.sp
-.BI "extern char *" optarg ;
-.BI "extern int " optind ", " opterr ", " optopt ;
-.sp
-.B #include <getopt.h>
-.sp
-.BI "int getopt_long(int " argc ", char * const " argv[] ",
-.BI " const char *" optstring ,
-.BI " const struct option *" longopts ", int *" longindex ");"
-.sp
-.BI "int getopt_long_only(int " argc ", char * const " argv[] ",
-.BI " const char *" optstring ,
-.BI " const struct option *" longopts ", int *" longindex ");"
-.fi
-.SH DESCRIPTION
-The
-.B getopt()
-function parses the command line arguments. Its arguments
-.I argc
-and
-.I argv
-are the argument count and array as passed to the
-.B main()
-function on program invocation.
-An element of \fIargv\fP that starts with `-' (and is not exactly "-" or "--")
-is an option element. The characters of this element
-(aside from the initial `-') are option characters. If \fBgetopt()\fP
-is called repeatedly, it returns successively each of the option characters
-from each of the option elements.
-.PP
-If \fBgetopt()\fP finds another option character, it returns that
-character, updating the external variable \fIoptind\fP and a static
-variable \fInextchar\fP so that the next call to \fBgetopt()\fP can
-resume the scan with the following option character or
-\fIargv\fP-element.
-.PP
-If there are no more option characters, \fBgetopt()\fP returns
-\fBEOF\fP. Then \fIoptind\fP is the index in \fIargv\fP of the first
-\fIargv\fP-element that is not an option.
-.PP
-.I optstring
-is a string containing the legitimate option characters. If such a
-character is followed by a colon, the option requires an argument, so
-\fBgetopt\fP places a pointer to the following text in the same
-\fIargv\fP-element, or the text of the following \fIargv\fP-element, in
-.IR optarg .
-Two colons mean an option takes
-an optional arg; if there is text in the current \fIargv\fP-element,
-it is returned in \fIoptarg\fP, otherwise \fIoptarg\fP is set to zero.
-.PP
-By default, \fBgetargs()\fP permutes the contents of \fIargv\fP as it
-scans, so that eventually all the non-options are at the end. Two
-other modes are also implemented. If the first character of
-\fIoptstring\fP is `+' or the environment variable POSIXLY_CORRECT is
-set, then option processing stops as soon as a non-option argument is
-encountered. If the first character of \fIoptstring\fP is `-', then
-each non-option \fIargv\fP-element is handled as if it were the argument of
-an option with character code 1. (This is used by programs that were
-written to expect options and other \fIargv\fP-elements in any order
-and that care about the ordering of the two.)
-The special argument `--' forces an end of option-scanning regardless
-of the scanning mode.
-.PP
-If \fBgetopt()\fP does not recognize an option character, it prints an
-error message to stderr, stores the character in \fIoptopt\fP, and
-returns `?'. The calling program may prevent the error message by
-setting \fIopterr\fP to 0.
-.PP
-The
-.B getopt_long()
-function works like
-.B getopt()
-except that it also accepts long options, started out by two dashes.
-Long option names may be abbreviated if the abbreviation is
-unique or is an exact match for some defined option. A long option
-may take a parameter, of the form
-.B --arg=param
-or
-.BR "--arg param" .
-.PP
-.I longopts
-is a pointer to the first element of an array of
-.B struct option
-declared in
-.B <getopt.h>
-as
-.nf
-.sp
-.in 10
-struct option {
-.in 14
-const char *name;
-int has_arg;
-int *flag;
-int val;
-.in 10
-};
-.fi
-.PP
-The meanings of the different fields are:
-.TP
-.I name
-is the name of the long option.
-.TP
-.I has_arg
-is:
-\fBno_argument\fP (or 0) if the option does not take an argument,
-\fBrequired_argument\fP (or 1) if the option requires an argument, or
-\fBoptional_argument\fP (or 2) if the option takes an optional argument.
-.TP
-.I flag
-specifies how results are returned for a long option. If \fIflag\fP
-is \fBNULL\fP, then \fBgetopt_long()\fP returns \fIval\fP. (For
-example, the calling program may set \fIval\fP to the equivalent short
-option character.) Otherwise, \fBgetopt_long()\fP returns 0, and
-\fIflag\fP points to a variable which is set to \fIval\fP if the
-option is found, but left unchanged if the option is not found.
-.TP
-\fIval\fP
-is the value to return, or to load into the variable pointed
-to by \fIflag\fP.
-.PP
-The last element of the array has to be filled with zeroes.
-.PP
-If \fIlongindex\fP is not \fBNULL\fP, it
-points to a variable which is set to the index of the long option relative to
-.IR longopts .
-.PP
-\fBgetopt_long_only()\fP is like \fBgetopt_long()\fP, but `-' as well
-as `--' can indicate a long option. If an option that starts with `-'
-(not `--') doesn't match a long option, but does match a short option,
-it is parsed as a short option instead.
-.SH "RETURN VALUE"
-The
-.B getopt()
-function returns the option character if the option was found
-successfully, `:' if there was a missing parameter for one of the
-options, `?' for an unknown option character, or \fBEOF\fP
-for the end of the option list.
-.PP
-\fBgetopt_long()\fP and \fBgetopt_long_only()\fP also return the option
-character when a short option is recognized. For a long option, they
-return \fIval\fP if \fIflag\fP is \fBNULL\fP, and 0 otherwise. Error
-and EOF returns are the same as for \fBgetopt()\fP, plus `?' for an
-ambiguous match or an extraneous parameter.
-.SH "ENVIRONMENT VARIABLES"
-.TP
-.SM
-.B POSIXLY_CORRECT
-If this is set, then option processing stops as soon as a non-option
-argument is encountered.
-.SH "EXAMPLE"
-The following example program, from the source code, illustrates the
-use of
-.BR getopt_long()
-with most of its features.
-.nf
-.sp
-#include <stdio.h>
-
-int
-main (argc, argv)
- int argc;
- char **argv;
-{
- int c;
- int digit_optind = 0;
-
- while (1)
- {
- int this_option_optind = optind ? optind : 1;
- int option_index = 0;
- static struct option long_options[] =
- {
- {"add", 1, 0, 0},
- {"append", 0, 0, 0},
- {"delete", 1, 0, 0},
- {"verbose", 0, 0, 0},
- {"create", 1, 0, 'c'},
- {"file", 1, 0, 0},
- {0, 0, 0, 0}
- };
-
- c = getopt_long (argc, argv, "abc:d:012",
- long_options, &option_index);
- if (c == -1)
- break;
-
- switch (c)
- {
- case 0:
- printf ("option %s", long_options[option_index].name);
- if (optarg)
- printf (" with arg %s", optarg);
- printf ("\\n");
- break;
-
- case '0':
- case '1':
- case '2':
- if (digit_optind != 0 && digit_optind != this_option_optind)
- printf ("digits occur in two different argv-elements.\\n");
- digit_optind = this_option_optind;
- printf ("option %c\\n", c);
- break;
-
- case 'a':
- printf ("option a\\n");
- break;
-
- case 'b':
- printf ("option b\\n");
- break;
-
- case 'c':
- printf ("option c with value `%s'\\n", optarg);
- break;
-
- case 'd':
- printf ("option d with value `%s'\\n", optarg);
- break;
-
- case '?':
- break;
-
- default:
- printf ("?? getopt returned character code 0%o ??\\n", c);
- }
- }
-
- if (optind < argc)
- {
- printf ("non-option ARGV-elements: ");
- while (optind < argc)
- printf ("%s ", argv[optind++]);
- printf ("\\n");
- }
-
- exit (0);
-}
-.fi
-.SH "BUGS"
-This manpage is confusing.
-.SH "CONFORMING TO"
-.TP
-\fBgetopt()\fP:
-POSIX.1, provided the environment variable POSIXLY_CORRECT is set.
-Otherwise, the elements of \fIargv\fP aren't really const, because we
-permute them. We pretend they're const in the prototype to be
-compatible with other systems.
-
diff --git a/common/win/my_getopt-1.5/getopt.h b/common/win/my_getopt-1.5/getopt.h
deleted file mode 100644
index df07082..0000000
--- a/common/win/my_getopt-1.5/getopt.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * getopt.h - cpp wrapper for my_getopt to make it look like getopt.
- * Copyright 1997, 2000, 2001, 2002, Benjamin Sittler
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef MY_WRAPPER_GETOPT_H_INCLUDED
-#define MY_WRAPPER_GETOPT_H_INCLUDED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "my_getopt.h"
-
-#undef getopt
-#define getopt my_getopt
-#undef getopt_long
-#define getopt_long my_getopt_long
-#undef getopt_long_only
-#define getopt_long_only my_getopt_long_only
-#undef _getopt_internal
-#define _getopt_internal _my_getopt_internal
-#undef opterr
-#define opterr my_opterr
-#undef optind
-#define optind my_optind
-#undef optopt
-#define optopt my_optopt
-#undef optarg
-#define optarg my_optarg
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MY_WRAPPER_GETOPT_H_INCLUDED */
diff --git a/common/win/my_getopt-1.5/getopt.txt b/common/win/my_getopt-1.5/getopt.txt
deleted file mode 100644
index ae08824..0000000
--- a/common/win/my_getopt-1.5/getopt.txt
+++ /dev/null
@@ -1,330 +0,0 @@
-
-
-
-GETOPT(3) Linux Programmer's Manual GETOPT(3)
-
-
-NAME
- getopt - Parse command line options
-
-SYNOPSIS
- #include <unistd.h>
-
- int getopt(int argc, char * const argv[],
- const char *optstring);
-
- extern char *optarg;
- extern int optind, opterr, optopt;
-
- #include <getopt.h>
-
- int getopt_long(int argc, char * const argv[],
- const char *optstring,
- const struct option *longopts, int *longindex);
-
- int getopt_long_only(int argc, char * const argv[],
- const char *optstring,
- const struct option *longopts, int *longindex);
-
-DESCRIPTION
- The getopt() function parses the command line arguments.
- Its arguments argc and argv are the argument count and
- array as passed to the main() function on program invoca-
- tion. An element of argv that starts with `-' (and is not
- exactly "-" or "--") is an option element. The characters
- of this element (aside from the initial `-') are option
- characters. If getopt() is called repeatedly, it returns
- successively each of the option characters from each of
- the option elements.
-
- If getopt() finds another option character, it returns
- that character, updating the external variable optind and
- a static variable nextchar so that the next call to
- getopt() can resume the scan with the following option
- character or argv-element.
-
- If there are no more option characters, getopt() returns
- EOF. Then optind is the index in argv of the first argv-
- element that is not an option.
-
- optstring is a string containing the legitimate option
- characters. If such a character is followed by a colon,
- the option requires an argument, so getopt places a
- pointer to the following text in the same argv-element, or
- the text of the following argv-element, in optarg. Two
- colons mean an option takes an optional arg; if there is
- text in the current argv-element, it is returned in
- optarg, otherwise optarg is set to zero.
-
- By default, getargs() permutes the contents of argv as it
- scans, so that eventually all the non-options are at the
-
-
-
-GNU Aug 30, 1995 1
-
-
-
-
-
-GETOPT(3) Linux Programmer's Manual GETOPT(3)
-
-
- end. Two other modes are also implemented. If the first
- character of optstring is `+' or the environment variable
- POSIXLY_CORRECT is set, then option processing stops as
- soon as a non-option argument is encountered. If the
- first character of optstring is `-', then each non-option
- argv-element is handled as if it were the argument of an
- option with character code 1. (This is used by programs
- that were written to expect options and other argv-ele-
- ments in any order and that care about the ordering of the
- two.) The special argument `--' forces an end of option-
- scanning regardless of the scanning mode.
-
- If getopt() does not recognize an option character, it
- prints an error message to stderr, stores the character in
- optopt, and returns `?'. The calling program may prevent
- the error message by setting opterr to 0.
-
- The getopt_long() function works like getopt() except that
- it also accepts long options, started out by two dashes.
- Long option names may be abbreviated if the abbreviation
- is unique or is an exact match for some defined option. A
- long option may take a parameter, of the form --arg=param
- or --arg param.
-
- longopts is a pointer to the first element of an array of
- struct option declared in <getopt.h> as
-
- struct option {
- const char *name;
- int has_arg;
- int *flag;
- int val;
- };
-
- The meanings of the different fields are:
-
- name is the name of the long option.
-
- has_arg
- is: no_argument (or 0) if the option does not take
- an argument, required_argument (or 1) if the option
- requires an argument, or optional_argument (or 2)
- if the option takes an optional argument.
-
- flag specifies how results are returned for a long
- option. If flag is NULL, then getopt_long()
- returns val. (For example, the calling program may
- set val to the equivalent short option character.)
- Otherwise, getopt_long() returns 0, and flag points
- to a variable which is set to val if the option is
- found, but left unchanged if the option is not
- found.
-
- val is the value to return, or to load into the
-
-
-
-GNU Aug 30, 1995 2
-
-
-
-
-
-GETOPT(3) Linux Programmer's Manual GETOPT(3)
-
-
- variable pointed to by flag.
-
- The last element of the array has to be filled with
- zeroes.
-
- If longindex is not NULL, it points to a variable which is
- set to the index of the long option relative to longopts.
-
- getopt_long_only() is like getopt_long(), but `-' as well
- as `--' can indicate a long option. If an option that
- starts with `-' (not `--') doesn't match a long option,
- but does match a short option, it is parsed as a short
- option instead.
-
-RETURN VALUE
- The getopt() function returns the option character if the
- option was found successfully, `:' if there was a missing
- parameter for one of the options, `?' for an unknown
- option character, or EOF for the end of the option list.
-
- getopt_long() and getopt_long_only() also return the
- option character when a short option is recognized. For a
- long option, they return val if flag is NULL, and 0 other-
- wise. Error and EOF returns are the same as for getopt(),
- plus `?' for an ambiguous match or an extraneous parame-
- ter.
-
-ENVIRONMENT VARIABLES
- POSIXLY_CORRECT
- If this is set, then option processing stops as
- soon as a non-option argument is encountered.
-
-EXAMPLE
- The following example program, from the source code,
- illustrates the use of getopt_long() with most of its fea-
- tures.
-
- #include <stdio.h>
-
- int
- main (argc, argv)
- int argc;
- char **argv;
- {
- int c;
- int digit_optind = 0;
-
- while (1)
- {
- int this_option_optind = optind ? optind : 1;
- int option_index = 0;
- static struct option long_options[] =
- {
- {"add", 1, 0, 0},
-
-
-
-GNU Aug 30, 1995 3
-
-
-
-
-
-GETOPT(3) Linux Programmer's Manual GETOPT(3)
-
-
- {"append", 0, 0, 0},
- {"delete", 1, 0, 0},
- {"verbose", 0, 0, 0},
- {"create", 1, 0, 'c'},
- {"file", 1, 0, 0},
- {0, 0, 0, 0}
- };
-
- c = getopt_long (argc, argv, "abc:d:012",
- long_options, &option_index);
- if (c == -1)
- break;
-
- switch (c)
- {
- case 0:
- printf ("option %s", long_options[option_index].name);
- if (optarg)
- printf (" with arg %s", optarg);
- printf ("\n");
- break;
-
- case '0':
- case '1':
- case '2':
- if (digit_optind != 0 && digit_optind != this_option_optind)
- printf ("digits occur in two different argv-elements.\n");
- digit_optind = this_option_optind;
- printf ("option %c\n", c);
- break;
-
- case 'a':
- printf ("option a\n");
- break;
-
- case 'b':
- printf ("option b\n");
- break;
-
- case 'c':
- printf ("option c with value `%s'\n", optarg);
- break;
-
- case 'd':
- printf ("option d with value `%s'\n", optarg);
- break;
-
- case '?':
- break;
-
- default:
- printf ("?? getopt returned character code 0%o ??\n", c);
- }
- }
-
-
-
-GNU Aug 30, 1995 4
-
-
-
-
-
-GETOPT(3) Linux Programmer's Manual GETOPT(3)
-
-
- if (optind < argc)
- {
- printf ("non-option ARGV-elements: ");
- while (optind < argc)
- printf ("%s ", argv[optind++]);
- printf ("\n");
- }
-
- exit (0);
- }
-
-BUGS
- This manpage is confusing.
-
-CONFORMING TO
- getopt():
- POSIX.1, provided the environment variable
- POSIXLY_CORRECT is set. Otherwise, the elements of
- argv aren't really const, because we permute them.
- We pretend they're const in the prototype to be
- compatible with other systems.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-GNU Aug 30, 1995 5
-
-
diff --git a/common/win/my_getopt-1.5/main.c b/common/win/my_getopt-1.5/main.c
deleted file mode 100644
index a9de272..0000000
--- a/common/win/my_getopt-1.5/main.c
+++ /dev/null
@@ -1,387 +0,0 @@
-/*
- * copy - test program for my getopt() re-implementation
- *
- * This program is in the public domain.
- */
-
-#define VERSION \
-"0.3"
-
-#define COPYRIGHT \
-"This program is in the public domain."
-
-/* for isprint(), printf(), fopen(), perror(), getenv(), strcmp(), etc. */
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* for my getopt() re-implementation */
-#include "getopt.h"
-
-/* the default verbosity level is 0 (no verbose reporting) */
-static unsigned verbose = 0;
-
-/* print version and copyright information */
-static void
-version(char *progname)
-{
- printf("%s version %s\n"
- "%s\n",
- progname,
- VERSION,
- COPYRIGHT);
-}
-
-/* print a help summary */
-static void
-help(char *progname)
-{
- printf("Usage: %s [options] [FILE]...\n"
- "Options:\n"
- "-h or -help show this message and exit\n"
- "-append append to the output file\n"
- "-o FILE or\n"
- "-output FILE send output to FILE (default is stdout)\n"
- "-r or --rotate rotate letters 13 positions (rot13)\n"
- "-rNUM or\n"
- "--rotate=NUM rotate letters NUM positions\n"
- "-truncate truncate the output file "
- "(this is the default)\n"
- "-v or -verbose increase the level of verbosity by 1"
- "(the default is 0)\n"
- "-vNUM or\n"
- "-verbose=NUM set the level of verbosity to NUM\n"
- "-V or -version print program version and exit\n"
- "\n"
- "This program reads the specified FILEs "
- "(or stdin if none are given)\n"
- "and writes their bytes to the specified output FILE "
- "(or stdout if none is\n"
- "given.) It can optionally rotate letters.\n",
- progname);
-}
-
-/* print usage information to stderr */
-static void
-usage(char *progname)
-{
- fprintf(stderr,
- "Summary: %s [-help] [-version] [options] [FILE]...\n",
- progname);
-}
-
-/* input file handler -- returns nonzero or exit()s on failure */
-static int
-handle(char *progname,
- FILE *infile, char *infilename,
- FILE *outfile, char *outfilename,
- int rotate)
-{
- int c;
- unsigned long bytes_copied = 0;
-
- if (verbose > 2)
- {
- fprintf(stderr,
- "%s: copying from `%s' to `%s'\n",
- progname,
- infilename,
- outfilename);
- }
- while ((c = getc(infile)) != EOF)
- {
- if (rotate && isalpha(c))
- {
- const char *letters = "abcdefghijklmnopqrstuvwxyz";
- char *match;
- if ((match = strchr(letters, tolower(c))))
- {
- char rc = letters[(match - letters + rotate) % 26];
- if (isupper(c))
- rc = toupper(rc);
- c = rc;
- }
- }
- if (putc(c, outfile) == EOF)
- {
- perror(outfilename);
- exit(1);
- }
- bytes_copied ++;
- }
- if (! feof(infile))
- {
- perror(infilename);
- return 1;
- }
- if (verbose > 2)
- {
- fprintf(stderr,
- "%s: %lu bytes copied from `%s' to `%s'\n",
- progname,
- bytes_copied,
- infilename,
- outfilename);
- }
- return 0;
-}
-
-/* argument parser and dispatcher */
-int
-main(int argc, char * argv[])
-{
- /* the program name */
- char *progname = argv[0];
- /* during argument parsing, opt contains the return value from getopt() */
- int opt;
- /* the output filename is initially 0 (a.k.a. stdout) */
- char *outfilename = 0;
- /* the default return value is initially 0 (success) */
- int retval = 0;
- /* initially we truncate */
- int append = 0;
- /* initially we don't rotate letters */
- int rotate = 0;
-
- /* short options string */
- char *shortopts = "Vho:r::v::";
- /* long options list */
- struct option longopts[] =
- {
- /* name, has_arg, flag, val */ /* longind */
- { "append", no_argument, 0, 0 }, /* 0 */
- { "truncate", no_argument, 0, 0 }, /* 1 */
- { "version", no_argument, 0, 'V' }, /* 3 */
- { "help", no_argument, 0, 'h' }, /* 4 */
- { "output", required_argument, 0, 'o' }, /* 5 */
- { "rotate", optional_argument, 0, 'r' }, /* 6 */
- { "verbose", optional_argument, 0, 'v' }, /* 7 */
- /* end-of-list marker */
- { 0, 0, 0, 0 }
- };
- /* long option list index */
- int longind = 0;
-
- /*
- * print a warning when the POSIXLY_CORRECT environment variable will
- * interfere with argument placement
- */
- if (getenv("POSIXLY_CORRECT"))
- {
- fprintf(stderr,
- "%s: "
- "Warning: implicit argument reordering disallowed by "
- "POSIXLY_CORRECT\n",
- progname);
- }
-
- /* parse all options from the command line */
- while ((opt =
- getopt_long_only(argc, argv, shortopts, longopts, &longind)) != -1)
- switch (opt)
- {
- case 0: /* a long option without an equivalent short option */
- switch (longind)
- {
- case 0: /* -append */
- append = 1;
- break;
- case 1: /* -truncate */
- append = 0;
- break;
- default: /* something unexpected has happened */
- fprintf(stderr,
- "%s: "
- "getopt_long_only unexpectedly returned %d for `--%s'\n",
- progname,
- opt,
- longopts[longind].name);
- return 1;
- }
- break;
- case 'V': /* -version */
- version(progname);
- return 0;
- case 'h': /* -help */
- help(progname);
- return 0;
- case 'r': /* -rotate[=NUM] */
- if (optarg)
- {
- /* we use this while trying to parse a numeric argument */
- char ignored;
- if (sscanf(optarg,
- "%d%c",
- &rotate,
- &ignored) != 1)
- {
- fprintf(stderr,
- "%s: "
- "rotation `%s' is not a number\n",
- progname,
- optarg);
- usage(progname);
- return 2;
- }
- /* normalize rotation */
- while (rotate < 0)
- {
- rotate += 26;
- }
- rotate %= 26;
- }
- else
- rotate = 13;
- break;
- case 'o': /* -output=FILE */
- outfilename = optarg;
- /* we allow "-" as a synonym for stdout here */
- if (! strcmp(optarg, "-"))
- {
- outfilename = 0;
- }
- break;
- case 'v': /* -verbose[=NUM] */
- if (optarg)
- {
- /* we use this while trying to parse a numeric argument */
- char ignored;
- if (sscanf(optarg,
- "%u%c",
- &verbose,
- &ignored) != 1)
- {
- fprintf(stderr,
- "%s: "
- "verbosity level `%s' is not a number\n",
- progname,
- optarg);
- usage(progname);
- return 2;
- }
- }
- else
- verbose ++;
- break;
- case '?': /* getopt_long_only noticed an error */
- usage(progname);
- return 2;
- default: /* something unexpected has happened */
- fprintf(stderr,
- "%s: "
- "getopt_long_only returned an unexpected value (%d)\n",
- progname,
- opt);
- return 1;
- }
-
- /* re-open stdout to outfilename, if requested */
- if (outfilename)
- {
- if (! freopen(outfilename, (append ? "a" : "w"), stdout))
- {
- perror(outfilename);
- return 1;
- }
- }
- else
- {
- /* make a human-readable version of the output filename "-" */
- outfilename = "stdout";
- /* you can't truncate stdout */
- append = 1;
- }
-
- if (verbose)
- {
- fprintf(stderr,
- "%s: verbosity level is %u; %s `%s'; rotation %d\n",
- progname,
- verbose,
- (append ? "appending to" : "truncating"),
- outfilename,
- rotate);
- }
-
- if (verbose > 1)
- {
- fprintf(stderr,
- "%s: %d input file(s) were given\n",
- progname,
- ((argc > optind) ? (argc - optind) : 0));
- }
-
- if (verbose > 3)
- {
- fprintf(stderr,
- "\topterr: %d\n\toptind: %d\n\toptopt: %d (%c)\n\toptarg: %s\n",
- opterr,
- optind,
- optopt, optopt,
- optarg ? optarg : "(null)");
- }
-
- /* handle each of the input files (or stdin, if no files were given) */
- if (optind < argc)
- {
- int argindex;
-
- for (argindex = optind; argindex < argc; argindex ++)
- {
- char *infilename = argv[argindex];
- FILE *infile;
-
- /* we allow "-" as a synonym for stdin here */
- if (! strcmp(infilename, "-"))
- {
- infile = stdin;
- infilename = "stdin";
- }
- else if (! (infile = fopen(infilename, "r")))
- {
- perror(infilename);
- retval = 1;
- continue;
- }
- if (handle(progname,
- infile, argv[optind],
- stdout, outfilename,
- rotate))
- {
- retval = 1;
- fclose(infile);
- continue;
- }
- if ((infile != stdin) && fclose(infile))
- {
- perror(infilename);
- retval = 1;
- }
- }
- }
- else
- {
- retval =
- handle(progname,
- stdin, "stdin",
- stdout, outfilename,
- rotate);
- }
-
- /* close stdout */
- if (fclose(stdout))
- {
- perror(outfilename);
- return 1;
- }
-
- if (verbose > 3)
- {
- fprintf(stderr,
- "%s: normal return, exit code is %d\n",
- progname,
- retval);
- }
- return retval;
-}
diff --git a/common/win/my_getopt-1.5/my_getopt.c b/common/win/my_getopt-1.5/my_getopt.c
deleted file mode 100644
index 5237b8e..0000000
--- a/common/win/my_getopt-1.5/my_getopt.c
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- * my_getopt.c - my re-implementation of getopt.
- * Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include <sys/types.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "my_getopt.h"
-
-int my_optind=1, my_opterr=1, my_optopt=0;
-char *my_optarg=0;
-
-/* reset argument parser to start-up values */
-int my_getopt_reset(void)
-{
- my_optind = 1;
- my_opterr = 1;
- my_optopt = 0;
- my_optarg = 0;
- return 0;
-}
-
-/* this is the plain old UNIX getopt, with GNU-style extensions. */
-/* if you're porting some piece of UNIX software, this is all you need. */
-/* this supports GNU-style permution and optional arguments */
-
-int my_getopt(int argc, char * argv[], const char *opts)
-{
- static int charind=0;
- char mode, colon_mode;
- int off = 0, opt = -1;
-
- if(getenv("POSIXLY_CORRECT")) colon_mode = mode = '+';
- else {
- if((colon_mode = *opts) == ':') off ++;
- if(((mode = opts[off]) == '+') || (mode == '-')) {
- off++;
- if((colon_mode != ':') && ((colon_mode = opts[off]) == ':'))
- off ++;
- }
- }
- my_optarg = 0;
- if(charind) {
- const char *s;
- my_optopt = argv[my_optind][charind];
- for(s=opts+off; *s; s++) if(my_optopt == *s) {
- charind++;
- if((*(++s) == ':') || ((my_optopt == 'W') && (*s == ';'))) {
- if(argv[my_optind][charind]) {
- my_optarg = &(argv[my_optind++][charind]);
- charind = 0;
- } else if(*(++s) != ':') {
- charind = 0;
- if(++my_optind >= argc) {
- if(my_opterr) fprintf(stderr,
- "%s: option requires an argument -- %c\n",
- argv[0], my_optopt);
- opt = (colon_mode == ':') ? ':' : '?';
- goto my_getopt_ok;
- }
- my_optarg = argv[my_optind++];
- }
- }
- opt = my_optopt;
- goto my_getopt_ok;
- }
- if(my_opterr) fprintf(stderr,
- "%s: illegal option -- %c\n",
- argv[0], my_optopt);
- opt = '?';
- if(argv[my_optind][++charind] == '\0') {
- my_optind++;
- charind = 0;
- }
- my_getopt_ok:
- if(charind && ! argv[my_optind][charind]) {
- my_optind++;
- charind = 0;
- }
- } else if((my_optind >= argc) ||
- ((argv[my_optind][0] == '-') &&
- (argv[my_optind][1] == '-') &&
- (argv[my_optind][2] == '\0'))) {
- my_optind++;
- opt = -1;
- } else if((argv[my_optind][0] != '-') ||
- (argv[my_optind][1] == '\0')) {
- char *tmp;
- int i, j, k;
-
- if(mode == '+') opt = -1;
- else if(mode == '-') {
- my_optarg = argv[my_optind++];
- charind = 0;
- opt = 1;
- } else {
- for(i=j=my_optind; i<argc; i++) if((argv[i][0] == '-') &&
- (argv[i][1] != '\0')) {
- my_optind=i;
- opt=my_getopt(argc, argv, opts);
- while(i > j) {
- tmp=argv[--i];
- for(k=i; k+1<my_optind; k++) argv[k]=argv[k+1];
- argv[--my_optind]=tmp;
- }
- break;
- }
- if(i == argc) opt = -1;
- }
- } else {
- charind++;
- opt = my_getopt(argc, argv, opts);
- }
- if (my_optind > argc) my_optind = argc;
- return opt;
-}
-
-/* this is the extended getopt_long{,_only}, with some GNU-like
- * extensions. Implements _getopt_internal in case any programs
- * expecting GNU libc getopt call it.
- */
-
-int _my_getopt_internal(int argc, char * argv[], const char *shortopts,
- const struct option *longopts, int *longind,
- int long_only)
-{
- char mode, colon_mode = *shortopts;
- int shortoff = 0, opt = -1;
-
- if(getenv("POSIXLY_CORRECT")) colon_mode = mode = '+';
- else {
- if((colon_mode = *shortopts) == ':') shortoff ++;
- if(((mode = shortopts[shortoff]) == '+') || (mode == '-')) {
- shortoff++;
- if((colon_mode != ':') && ((colon_mode = shortopts[shortoff]) == ':'))
- shortoff ++;
- }
- }
- my_optarg = 0;
- if((my_optind >= argc) ||
- ((argv[my_optind][0] == '-') &&
- (argv[my_optind][1] == '-') &&
- (argv[my_optind][2] == '\0'))) {
- my_optind++;
- opt = -1;
- } else if((argv[my_optind][0] != '-') ||
- (argv[my_optind][1] == '\0')) {
- char *tmp;
- int i, j, k;
-
- opt = -1;
- if(mode == '+') return -1;
- else if(mode == '-') {
- my_optarg = argv[my_optind++];
- return 1;
- }
- for(i=j=my_optind; i<argc; i++) if((argv[i][0] == '-') &&
- (argv[i][1] != '\0')) {
- my_optind=i;
- opt=_my_getopt_internal(argc, argv, shortopts,
- longopts, longind,
- long_only);
- while(i > j) {
- tmp=argv[--i];
- for(k=i; k+1<my_optind; k++)
- argv[k]=argv[k+1];
- argv[--my_optind]=tmp;
- }
- break;
- }
- } else if((!long_only) && (argv[my_optind][1] != '-'))
- opt = my_getopt(argc, argv, shortopts);
- else {
- int charind, offset;
- int found = 0, ind, hits = 0;
-
- if(((my_optopt = argv[my_optind][1]) != '-') && ! argv[my_optind][2]) {
- int c;
-
- ind = shortoff;
- while((c = shortopts[ind++])) {
- if(((shortopts[ind] == ':') ||
- ((c == 'W') && (shortopts[ind] == ';'))) &&
- (shortopts[++ind] == ':'))
- ind ++;
- if(my_optopt == c) return my_getopt(argc, argv, shortopts);
- }
- }
- offset = 2 - (argv[my_optind][1] != '-');
- for(charind = offset;
- (argv[my_optind][charind] != '\0') &&
- (argv[my_optind][charind] != '=');
- charind++);
- for(ind = 0; longopts[ind].name && !hits; ind++)
- if((strlen(longopts[ind].name) == (size_t) (charind - offset)) &&
- (strncmp(longopts[ind].name,
- argv[my_optind] + offset, charind - offset) == 0))
- found = ind, hits++;
- if(!hits) for(ind = 0; longopts[ind].name; ind++)
- if(strncmp(longopts[ind].name,
- argv[my_optind] + offset, charind - offset) == 0)
- found = ind, hits++;
- if(hits == 1) {
- opt = 0;
-
- if(argv[my_optind][charind] == '=') {
- if(longopts[found].has_arg == 0) {
- opt = '?';
- if(my_opterr) fprintf(stderr,
- "%s: option `--%s' doesn't allow an argument\n",
- argv[0], longopts[found].name);
- } else {
- my_optarg = argv[my_optind] + ++charind;
- charind = 0;
- }
- } else if(longopts[found].has_arg == 1) {
- if(++my_optind >= argc) {
- opt = (colon_mode == ':') ? ':' : '?';
- if(my_opterr) fprintf(stderr,
- "%s: option `--%s' requires an argument\n",
- argv[0], longopts[found].name);
- } else my_optarg = argv[my_optind];
- }
- if(!opt) {
- if (longind) *longind = found;
- if(!longopts[found].flag) opt = longopts[found].val;
- else *(longopts[found].flag) = longopts[found].val;
- }
- my_optind++;
- } else if(!hits) {
- if(offset == 1) opt = my_getopt(argc, argv, shortopts);
- else {
- opt = '?';
- if(my_opterr) fprintf(stderr,
- "%s: unrecognized option `%s'\n",
- argv[0], argv[my_optind++]);
- }
- } else {
- opt = '?';
- if(my_opterr) fprintf(stderr,
- "%s: option `%s' is ambiguous\n",
- argv[0], argv[my_optind++]);
- }
- }
- if (my_optind > argc) my_optind = argc;
- return opt;
-}
-
-int my_getopt_long(int argc, char * argv[], const char *shortopts,
- const struct option *longopts, int *longind)
-{
- return _my_getopt_internal(argc, argv, shortopts, longopts, longind, 0);
-}
-
-int my_getopt_long_only(int argc, char * argv[], const char *shortopts,
- const struct option *longopts, int *longind)
-{
- return _my_getopt_internal(argc, argv, shortopts, longopts, longind, 1);
-}
diff --git a/common/win/my_getopt-1.5/my_getopt.h b/common/win/my_getopt-1.5/my_getopt.h
deleted file mode 100644
index c75101a..0000000
--- a/common/win/my_getopt-1.5/my_getopt.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * my_getopt.h - interface to my re-implementation of getopt.
- * Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef MY_GETOPT_H_INCLUDED
-#define MY_GETOPT_H_INCLUDED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* reset argument parser to start-up values */
-extern int my_getopt_reset(void);
-
-/* UNIX-style short-argument parser */
-extern int my_getopt(int argc, char * argv[], const char *opts);
-
-extern int my_optind, my_opterr, my_optopt;
-extern char *my_optarg;
-
-struct option {
- const char *name;
- int has_arg;
- int *flag;
- int val;
-};
-
-/* human-readable values for has_arg */
-#undef no_argument
-#define no_argument 0
-#undef required_argument
-#define required_argument 1
-#undef optional_argument
-#define optional_argument 2
-
-/* GNU-style long-argument parsers */
-extern int my_getopt_long(int argc, char * argv[], const char *shortopts,
- const struct option *longopts, int *longind);
-
-extern int my_getopt_long_only(int argc, char * argv[], const char *shortopts,
- const struct option *longopts, int *longind);
-
-extern int _my_getopt_internal(int argc, char * argv[], const char *shortopts,
- const struct option *longopts, int *longind,
- int long_only);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MY_GETOPT_H_INCLUDED */
--
1.7.7.6
More information about the Spice-devel
mailing list