pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2025-12-26 22:48:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove all mentions of "cairo" from the code

Browse Source 
The command line option is renamed from "cairo" to "sw", and
similarly all filenames and types from Cairo to Sw (and similar).
This commit is contained in:
Alexander Larsson 2010-05-03 12:08:00 +02:00
parent 295c8ed8bc
commit ae40f270cf
33 changed files with 253 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
client/Makefile.am
View File

@ -3,20 +3,20 @@ NULL =
SUBDIRS = $(red_target)
DIST_SUBDIRS = x11 #windows
RED_COMMON_SRCS = \
RED_COMMON_SRCS = \
application.cpp \
application.h \
audio_channels.h \
audio_devices.h \
cache.hpp \
cairo_canvas.cpp \
sw_canvas.cpp \
pixman_utils.cpp \
lines.cpp \
canvas.cpp \
canvas.h \
canvas_utils.cpp \
red_cairo_canvas.cpp \
red_cairo_canvas.h \
red_sw_canvas.cpp \
red_sw_canvas.h \
client_net_socket.cpp \
client_net_socket.h \
cmd_line_parser.cpp \
@ -66,7 +66,7 @@ RED_COMMON_SRCS = \
red_key.h \
red_peer.cpp \
red_peer.h \
red_pixmap_cairo.h \
red_pixmap_sw.h \
red_pixmap_gl.h \
red_pixmap.h \
red_types.h \
@ -82,8 +82,8 @@ RED_COMMON_SRCS = \
tunnel_channel.h \
hot_keys.cpp \
hot_keys.h \
threads.cpp \
threads.h \
threads.cpp \
threads.h \
utils.cpp \
utils.h \
$(NULL)

8
client/application.cpp
View File

@ -35,7 +35,7 @@
#include "red_gdi_canvas.h"
#endif
#include "platform.h"
#include "cairo_canvas.h"
#include "sw_canvas.h"
#include "gl_canvas.h"
#include "quic.h"
#include "mutex.h"
@ -378,7 +378,7 @@ Application::Application()
#ifdef WIN32
_canvas_types[0] = CANVAS_OPTION_GDI;
#else
_canvas_types[0] = CANVAS_OPTION_CAIRO;
_canvas_types[0] = CANVAS_OPTION_SW;
#endif
_host_auth_opt.type_flags = RedPeer::HostAuthOptions::HOST_AUTH_OP_NAME;
@ -1793,7 +1793,7 @@ bool Application::set_canvas_option(CmdLineParser& parser, char *val, const char
typedef std::map< std::string, CanvasOption> CanvasNamesMap;
CanvasNamesMap canvas_types;
canvas_types["cairo"] = CANVAS_OPTION_CAIRO;
canvas_types["sw"] = CANVAS_OPTION_SW;
#ifdef WIN32
canvas_types["gdi"] = CANVAS_OPTION_GDI;
#endif
@ -2130,7 +2130,7 @@ void Application::init_globals()
SSL_library_init();
SSL_load_error_strings();
cairo_canvas_init();
sw_canvas_init();
#ifdef USE_OGL
gl_canvas_init();
#endif

2
client/application.h
View File

@ -100,7 +100,7 @@ private:
enum CanvasOption {
CANVAS_OPTION_INVALID,
CANVAS_OPTION_CAIRO,
CANVAS_OPTION_SW,
#ifdef WIN32
CANVAS_OPTION_GDI,
#endif

2
client/canvas.h
View File

@ -32,7 +32,7 @@
enum CanvasType {
CANVAS_TYPE_INVALID,
CANVAS_TYPE_CAIRO,
CANVAS_TYPE_SW,
CANVAS_TYPE_GL,
CANVAS_TYPE_GDI,
};

18
client/cursor_channel.cpp
View File

@ -24,7 +24,7 @@
#include "debug.h"
#include "utils.h"
#include "screen.h"
#include "red_pixmap_cairo.h"
#include "red_pixmap_sw.h"
#include "rect.h"
static inline uint8_t revers_bits(uint8_t byte)
@ -111,8 +111,8 @@ void UnsupportedCursor::draw(RedDrawable& dest, int x, int y, const SpiceRect& a
}
AlphaCursor::AlphaCursor(const SpiceCursorHeader& header, const uint8_t* data)
: _pixmap (new RedPixmapCairo(header.width, header.height,
RedDrawable::ARGB32, true, NULL))
: _pixmap (new RedPixmapSw(header.width, header.height,
RedDrawable::ARGB32, true, NULL))
{
int stride = _pixmap->get_stride();
uint8_t* dest = _pixmap->get_data();
@ -131,8 +131,8 @@ MonoCursor::MonoCursor(const SpiceCursorHeader& header, const uint8_t* data)
: _pixmap (NULL)
, _height (header.height)
{
_pixmap.reset(new RedPixmapCairo(header.width, _height * 2, RedDrawable::A1,
true, NULL));
_pixmap.reset(new RedPixmapSw(header.width, _height * 2, RedDrawable::A1,
true, NULL));
int dest_stride = _pixmap->get_stride();
uint8_t *dest_line = _pixmap->get_data();
@ -175,12 +175,12 @@ private:
};
ColorCursor::ColorCursor(const SpiceCursorHeader& header)
: _pixmap (new RedPixmapCairo(header.width, header.height,
RedDrawable::ARGB32, true, NULL))
: _pixmap (new RedPixmapSw(header.width, header.height,
RedDrawable::ARGB32, true, NULL))
, _invers (NULL)
{
_invers.reset(new RedPixmapCairo(header.width, header.height, RedDrawable::A1,
true, NULL));
_invers.reset(new RedPixmapSw(header.width, header.height, RedDrawable::A1,
true, NULL));
}
void ColorCursor::init_pixels(const SpiceCursorHeader& header, const uint8_t* pixels,

10
client/display_channel.cpp
View File

@ -31,7 +31,7 @@
#ifdef USE_OGL
#include "red_gl_canvas.h"
#endif
#include "red_cairo_canvas.h"
#include "red_sw_canvas.h"
#include "red_client.h"
#include "utils.h"
#include "debug.h"
@ -1080,17 +1080,17 @@ void DisplayChannel::on_disconnect()
(*sync_event)->wait();
}
bool DisplayChannel::create_cairo_canvas(int surface_id, int width, int height, uint32_t format)
bool DisplayChannel::create_sw_canvas(int surface_id, int width, int height, uint32_t format)
{
try {
CCanvas *canvas = new CCanvas(surface_id == 0, width, height, format,
SCanvas *canvas = new SCanvas(surface_id == 0, width, height, format,
screen()->get_window(),
_pixmap_cache, _palette_cache, _glz_window,
surfaces_mngr.get_surfaces());
surfaces_mngr.add_canvas(surface_id, canvas);
surfaces_mngr.add_surface(surface_id, canvas->get_internal_canvas());
if (surface_id == 0) {
LOG_INFO("display %d: using cairo", get_id());
LOG_INFO("display %d: using sw", get_id());
}
} catch (...) {
return false;
@ -1188,7 +1188,7 @@ void DisplayChannel::create_canvas(int surface_id, const std::vector<int>& canva
for (i = 0; i < canvas_types.size(); i++) {
if (canvas_types[i] == CANVAS_OPTION_CAIRO && create_cairo_canvas(surface_id, width, height, format)) {
if (canvas_types[i] == CANVAS_OPTION_SW && create_sw_canvas(surface_id, width, height, format)) {
break;
}
#ifdef USE_OGL

2
client/display_channel.h
View File

@ -133,7 +133,7 @@ protected:
private:
void set_draw_handlers();
void clear_draw_handlers();
bool create_cairo_canvas(int surface_id, int width, int height, uint32_t format);
bool create_sw_canvas(int surface_id, int width, int height, uint32_t format);
#ifdef USE_OGL
bool create_ogl_canvas(int surface_id, int width, int height, uint32_t format, bool recreate,
RenderType rendertype);

4
client/gui/gui.cpp
View File

@ -7,7 +7,7 @@
#include "screen.h"
#include "utils.h"
#include "debug.h"
#include "red_pixmap_cairo.h"
#include "red_pixmap_sw.h"
#include "resource_provider.h"
#include "CEGUISystem.h"
@ -888,7 +888,7 @@ GUI::GUI(Application& app, Application::State state)
: ScreenLayer (SCREEN_LAYER_GUI, false)
, _app (app)
, _state (state)
, _pixmap (new RedPixmapCairo(MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT, RedDrawable::RGB32, true, 0))
, _pixmap (new RedPixmapSw(MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT, RedDrawable::RGB32, true, 0))
, _renderer (new CEGUI::SoftRenderer(_pixmap->get_data(), MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT,
_pixmap->get_stride()))
, _gui_system (new CEGUI::System(_renderer, new CEGUIResourceProvider()))

4
client/gui/gui.h
View File

@ -6,7 +6,7 @@
#include "inputs_handler.h"
#include "application.h"
class RedPixmapCairo;
class RedPixmapSw;
class GUI : public ScreenLayer, public KeyHandler {
public:
@ -86,7 +86,7 @@ private:
private:
Application& _app;
Application::State _state;
RedPixmapCairo* _pixmap;
RedPixmapSw* _pixmap;
CEGUI::SoftRenderer* _renderer;
CEGUI::System* _gui_system;
Dialog* _dialog;

2
client/red_gl_canvas.h
View File

@ -19,7 +19,7 @@
#define _H_GCANVAS
#include "canvas.h"
#include "cairo_canvas.h"
#include "sw_canvas.h"
#include "gl_canvas.h"
#include "red_pixmap_gl.h"
#include "red_window.h"

4
client/red_pixmap_gdi.h
View File

@ -16,8 +16,8 @@
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _H_RED_PIXMAP_CAIRO
#define _H_RED_PIXMAP_CAIRO
#ifndef _H_RED_PIXMAP_GDI
#define _H_RED_PIXMAP_GDI
#include "red_pixmap.h"

10
client/red_pixmap_cairo.h → client/red_pixmap_sw.h
View File

@ -15,16 +15,16 @@
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _H_RED_PIXMAP_CAIRO
#define _H_RED_PIXMAP_CAIRO
#ifndef _H_RED_PIXMAP_SW
#define _H_RED_PIXMAP_SW
#include "red_pixmap.h"
#include "red_window.h"
class RedPixmapCairo: public RedPixmap {
class RedPixmapSw: public RedPixmap {
public:
RedPixmapCairo(int width, int height, Format format, bool top_bottom, RedWindow *window);
~RedPixmapCairo();
RedPixmapSw(int width, int height, Format format, bool top_bottom, RedWindow *window);
~RedPixmapSw();
};
#endif

22
client/red_cairo_canvas.cpp → client/red_sw_canvas.cpp
View File

@ -19,13 +19,13 @@
#include "common.h"
#include <stdint.h>
#include "red_window.h"
#include "red_cairo_canvas.h"
#include "red_sw_canvas.h"
#include "utils.h"
#include "debug.h"
#include "region.h"
#include "red_pixmap_cairo.h"
#include "red_pixmap_sw.h"
CCanvas::CCanvas(bool onscreen,
SCanvas::SCanvas(bool onscreen,
int width, int height, uint32_t format, RedWindow *win,
PixmapCache& pixmap_cache, PaletteCache& palette_cache,
GlzDecoderWindow &glz_decoder_window, CSurfaces& csurfaces)
@ -33,9 +33,9 @@ CCanvas::CCanvas(bool onscreen,
, _pixmap (0)
{
if (onscreen) {
_pixmap = new RedPixmapCairo(width, height,
RedDrawable::format_from_surface(format),
true, win);
_pixmap = new RedPixmapSw(width, height,
RedDrawable::format_from_surface(format),
true, win);
_canvas = canvas_create_for_data(width, height, format,
_pixmap->get_data(),
_pixmap->get_stride(),
@ -55,7 +55,7 @@ CCanvas::CCanvas(bool onscreen,
}
}
CCanvas::~CCanvas()
SCanvas::~SCanvas()
{
_canvas->ops->destroy(_canvas);
_canvas = NULL;
@ -65,7 +65,7 @@ CCanvas::~CCanvas()
}
}
void CCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
void SCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
{
pixman_box32_t *rects;
int num_rects;
@ -84,13 +84,13 @@ void CCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
}
}
void CCanvas::copy_pixels(const QRegion& region, RedDrawable* dest_dc, const PixmapHeader* pixmap)
void SCanvas::copy_pixels(const QRegion& region, RedDrawable* dest_dc, const PixmapHeader* pixmap)
{
copy_pixels(region, *dest_dc);
}
CanvasType CCanvas::get_pixmap_type()
CanvasType SCanvas::get_pixmap_type()
{
return CANVAS_TYPE_CAIRO;
return CANVAS_TYPE_SW;
}

8
client/red_cairo_canvas.h → client/red_sw_canvas.h
View File

@ -20,17 +20,17 @@
#define _H_CCANVAS
#include "canvas.h"
#include "cairo_canvas.h"
#include "sw_canvas.h"
class RedPixmap;
class CCanvas: public Canvas {
class SCanvas: public Canvas {
public:
CCanvas(bool onscreen,
SCanvas(bool onscreen,
int width, int height, uint32_t format, RedWindow *win,
PixmapCache& pixmap_cache, PaletteCache& palette_cache,
GlzDecoderWindow &glz_decoder_window, CSurfaces &csurfaces);
virtual ~CCanvas();
virtual ~SCanvas();
virtual void thread_touch() {}
virtual void copy_pixels(const QRegion& region, RedDrawable* dc,

6
client/screen.cpp
View File

@ -22,7 +22,7 @@
#include "utils.h"
#include "debug.h"
#include "monitor.h"
#include "red_pixmap_cairo.h"
#include "red_pixmap_sw.h"
#include "resource.h"
#include "icon.h"
@ -171,8 +171,8 @@ void RedScreen::destroy_composit_area()
void RedScreen::create_composit_area()
{
destroy_composit_area();
_composit_area = new RedPixmapCairo(_size.x, _size.y, _window.get_format(),
false, &_window);
_composit_area = new RedPixmapSw(_size.x, _size.y, _window.get_format(),
false, &_window);
}
void RedScreen::adjust_window_rect(int x, int y)

2
client/cairo_canvas.cpp → client/sw_canvas.cpp
View File

@ -20,5 +20,5 @@
#define CANVAS_ERROR(format, ...) THROW(format, ## __VA_ARGS__)
#include "../common/cairo_canvas.c"
#include "../common/sw_canvas.c"

8
client/windows/red_pixmap_cairo.cpp → client/windows/red_pixmap_sw.cpp
View File

@ -17,7 +17,7 @@
*/
#include "common.h"
#include "red_pixmap_cairo.h"
#include "red_pixmap_sw.h"
#include "red_pixmap.h"
#include "debug.h"
#include "utils.h"
@ -29,8 +29,8 @@ struct RedPixmap_p {
HBITMAP prev_bitmap;
};
RedPixmapCairo::RedPixmapCairo(int width, int height, RedDrawable::Format format,
bool top_bottom, RedWindow *win)
RedPixmapSw::RedPixmapSw(int width, int height, RedDrawable::Format format,
bool top_bottom, RedWindow *win)
: RedPixmap(width, height, format, top_bottom)
{
DWORD *pixel_format;
@ -98,7 +98,7 @@ RedPixmapCairo::RedPixmapCairo(int width, int height, RedDrawable::Format format
((RedPixmap_p*)get_opaque())->pixels_source_p.dc = dc.release();
}
RedPixmapCairo::~RedPixmapCairo()
RedPixmapSw::~RedPixmapSw()
{
HDC dc = ((RedPixmap_p*)get_opaque())->pixels_source_p.dc;
if (dc) {

12
client/windows/redc.vcproj
View File

@ -43,7 +43,7 @@
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".;..;..\..\common;..\..\..\spice-protocol;..\..\common\win;&quot;..\..\common\win\my_getopt-1.5&quot;;&quot;$(SPICE_LIBS)\include&quot;;&quot;$(SPICE_LIBS)\include\pixman-1&quot;;&quot;$(SPICE_LIBS)\include\CEGUI-0.6.2&quot;"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;CAIRO_CANVAS_ACCESS_TEST;CAIRO_CANVAS_CACHE;RED_DEBUG;CAIRO_CANVAS_NO_CHUNKS;_WIN32_WINNT=0x0500;LOG4CPLUS_STATIC;USE_GLZ;PTW32_STATIC_LIB;CEGUI_STATIC"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;SW_CANVAS_ACCESS_TEST;SW_CANVAS_CACHE;RED_DEBUG;SW_CANVAS_NO_CHUNKS;_WIN32_WINNT=0x0500;LOG4CPLUS_STATIC;USE_GLZ;PTW32_STATIC_LIB;CEGUI_STATIC"
MinimalRebuild="false"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
@ -125,7 +125,7 @@
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories=".;..;..\..\..\spice-protocol;..\..\common;..\..\common\win;&quot;..\..\common\win\my_getopt-1.5&quot;;&quot;$(SPICE_LIBS)\include&quot;;&quot;$(SPICE_LIBS)\include\pixman-1&quot;;&quot;$(SPICE_LIBS)\include\CEGUI-0.6.2&quot;"
PreprocessorDefinitions="WIN32;_WINDOWS;CAIRO_CANVAS_ACCESS_TEST;CAIRO_CANVAS_CACHE;CAIRO_CANVAS_NO_CHUNKS;_WIN32_WINNT=0x0500;LOG4CPLUS_STATIC;USE_GLZ;PTW32_STATIC_LIB;CEGUI_STATIC"
PreprocessorDefinitions="WIN32;_WINDOWS;SW_CANVAS_ACCESS_TEST;SW_CANVAS_CACHE;SW_CANVAS_NO_CHUNKS;_WIN32_WINNT=0x0500;LOG4CPLUS_STATIC;USE_GLZ;PTW32_STATIC_LIB;CEGUI_STATIC"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="3"
@ -192,7 +192,7 @@
>
</File>
<File
RelativePath="..\cairo_canvas.cpp"
RelativePath="..\sw_canvas.cpp"
>
</File>
<File
@ -346,7 +346,7 @@
>
</File>
<File
RelativePath="..\red_cairo_canvas.cpp"
RelativePath="..\red_sw_canvas.cpp"
>
</File>
<File
@ -374,7 +374,7 @@
>
</File>
<File
RelativePath=".\red_pixmap_cairo.cpp"
RelativePath=".\red_pixmap_sw.cpp"
>
</File>
<File
@ -564,7 +564,7 @@
>
</File>
<File
RelativePath="..\red_cairo_canvas.h"
RelativePath="..\red_sw_canvas.h"
>
</File>
<File

16
client/x11/Makefile.am
View File

@ -6,9 +6,9 @@ CLIENT_DIR=$(top_srcdir)/client
SUBDIRS = images
INCLUDES = \
-DCAIRO_CANVAS_ACCESS_TEST \
-DCAIRO_CANVAS_CACHE \
-DCAIRO_CANVAS_NO_CHUNKS \
-DSW_CANVAS_ACCESS_TEST \
-DSW_CANVAS_CACHE \
-DSW_CANVAS_NO_CHUNKS \
-DUSE_GLZ \
-DUSE_OGL \
-D__STDC_LIMIT_MACROS \
@ -38,12 +38,12 @@ RED_COMMON_SRCS = \
$(CLIENT_DIR)/audio_channels.h \
$(CLIENT_DIR)/audio_devices.h \
$(CLIENT_DIR)/cache.hpp \
$(CLIENT_DIR)/cairo_canvas.cpp \
$(CLIENT_DIR)/sw_canvas.cpp \
$(CLIENT_DIR)/canvas.cpp \
$(CLIENT_DIR)/canvas.h \
$(CLIENT_DIR)/canvas_utils.cpp \
$(CLIENT_DIR)/red_cairo_canvas.cpp \
$(CLIENT_DIR)/red_cairo_canvas.h \
$(CLIENT_DIR)/red_sw_canvas.cpp \
$(CLIENT_DIR)/red_sw_canvas.h \
$(CLIENT_DIR)/cmd_line_parser.cpp \
$(CLIENT_DIR)/cmd_line_parser.h \
$(CLIENT_DIR)/client_net_socket.cpp \
@ -93,7 +93,7 @@ RED_COMMON_SRCS = \
$(CLIENT_DIR)/red_key.h \
$(CLIENT_DIR)/red_peer.cpp \
$(CLIENT_DIR)/red_peer.h \
$(CLIENT_DIR)/red_pixmap_cairo.h \
$(CLIENT_DIR)/red_pixmap_sw.h \
$(CLIENT_DIR)/red_pixmap_gl.h \
$(CLIENT_DIR)/red_pixmap.h \
$(CLIENT_DIR)/red_types.h \
@ -142,7 +142,7 @@ spicec_SOURCES = \
record.h \
red_drawable.cpp \
red_pixmap.cpp \
red_pixmap_cairo.cpp \
red_pixmap_sw.cpp \
red_pixmap_gl.cpp \
red_window.cpp \
red_window_p.h \

12
client/x11/red_pixmap_cairo.cpp → client/x11/red_pixmap_sw.cpp
View File

@ -17,19 +17,19 @@
*/
#include "common.h"
#include "red_pixmap_cairo.h"
#include "red_pixmap_sw.h"
#include "debug.h"
#include "utils.h"
#include "pixels_source_p.h"
#include "x_platform.h"
RedPixmapCairo::RedPixmapCairo(int width, int height, RedDrawable::Format format,
bool top_bottom, RedWindow *win)
RedPixmapSw::RedPixmapSw(int width, int height, RedDrawable::Format format,
bool top_bottom, RedWindow *win)
: RedPixmap(width, height, format, top_bottom)
{
ASSERT(format == RedDrawable::ARGB32 || format == RedDrawable::RGB32 ||
format == RedDrawable::RGB16_555 || format == RedDrawable::RGB16_565 ||
format == RedDrawable::A1);
format == RedDrawable::RGB16_555 || format == RedDrawable::RGB16_565 ||
format == RedDrawable::A1);
ASSERT(sizeof(RedDrawable_p) <= PIXELES_SOURCE_OPAQUE_SIZE);
pixman_image_t *pixman_image;
XImage *image;
@ -73,7 +73,7 @@ RedPixmapCairo::RedPixmapCairo(int width, int height, RedDrawable::Format format
((PixelsSource_p*)get_opaque())->pixmap.format = format;
}
RedPixmapCairo::~RedPixmapCairo()
RedPixmapSw::~RedPixmapSw()
{
ASSERT(((PixelsSource_p*)get_opaque())->type == PIXELS_SOURCE_TYPE_PIXMAP);

4
common/Makefile.am
View File

@ -1,8 +1,8 @@
NULL =
COMMON_SRCS = \
cairo_canvas.h \
cairo_canvas.c \
sw_canvas.h \
sw_canvas.c \
pixman_utils.h \
pixman_utils.c \
canvas_base.h \

50
common/canvas_base.c
View File

@ -43,7 +43,7 @@
}
#endif
#ifdef CAIRO_CANVAS_ACCESS_TEST
#ifdef SW_CANVAS_ACCESS_TEST
#define access_test(cancas, ptr, size) \
if ((unsigned long)(ptr) < (cancas)->base || \
(unsigned long)(ptr) + (size) > (cancas)->max) { \
@ -163,7 +163,7 @@ typedef struct QuicData {
QuicUsrContext usr;
QuicContext *quic;
jmp_buf jmp_env;
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
SPICE_ADDRESS next;
SpiceVirtMapping *virt_mapping;
#endif
@ -175,7 +175,7 @@ typedef struct CanvasBase {
uint32_t color_shift;
uint32_t color_mask;
QuicData quic_data;
#ifdef CAIRO_CANVAS_ACCESS_TEST
#ifdef SW_CANVAS_ACCESS_TEST
unsigned long base;
unsigned long max;
#endif
@ -185,10 +185,10 @@ typedef struct CanvasBase {
int height;
pixman_region32_t canvas_region;
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
SpiceImageCache *bits_cache;
#endif
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
SpicePaletteCache *palette_cache;
#endif
#ifdef WIN32
@ -205,7 +205,7 @@ typedef struct CanvasBase {
} CanvasBase;
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
#ifdef __GNUC__
#define ATTR_PACKED __attribute__ ((__packed__))
@ -453,7 +453,7 @@ static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceQUICImage *image
int stride;
int width;
int height;
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
DataChunk **tmp;
DataChunk *chunk;
#endif
@ -463,7 +463,7 @@ static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceQUICImage *image
CANVAS_ERROR("quic error, %s", quic_data->message_buf);
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
#ifdef SW_CANVAS_NO_CHUNKS
if (quic_decode_begin(quic_data->quic, (uint32_t *)image->quic.data,
image->quic.data_size >> 2, &type, &width, &height) == QUIC_ERROR) {
CANVAS_ERROR("quic decode begin failed");
@ -586,7 +586,7 @@ static pixman_image_t *canvas_bitmap_to_surface(CanvasBase *canvas, SpiceBitmap*
}
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
static inline SpicePalette *canvas_get_palette(CanvasBase *canvas, SPICE_ADDRESS base_palette, uint8_t flags)
{
@ -942,7 +942,7 @@ static SpiceCanvas *canvas_get_surface_mask_internal(CanvasBase *canvas, SPICE_A
return NULL;
}
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
//#define DEBUG_LZ
@ -987,7 +987,7 @@ static pixman_image_t *canvas_get_image_internal(CanvasBase *canvas, SPICE_ADDRE
surface = canvas_get_quic(canvas, image, 0, want_original);
break;
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
#ifdef SW_CANVAS_NO_CHUNKS
case SPICE_IMAGE_TYPE_LZ_PLT: {
access_test(canvas, descriptor, sizeof(SpiceLZPLTImage));
LZImage *image = (LZImage *)descriptor;
@ -1002,7 +1002,7 @@ static pixman_image_t *canvas_get_image_internal(CanvasBase *canvas, SPICE_ADDRE
}
#endif
#if defined(CAIRO_CANVAS_CACHE)
#if defined(SW_CANVAS_CACHE)
case SPICE_IMAGE_TYPE_GLZ_RGB: {
access_test(canvas, descriptor, sizeof(SpiceLZRGBImage));
LZImage *image = (LZImage *)descriptor;
@ -1340,7 +1340,7 @@ static pixman_image_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask, int
access_test(canvas, descriptor, sizeof(SpiceImageDescriptor));
need_invers = mask->flags & SPICE_MASK_FLAGS_INVERS;
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
cache_me = descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME;
#else
cache_me = 0;
@ -1354,7 +1354,7 @@ static pixman_image_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask, int
surface = canvas_get_bitmap_mask(canvas, &bitmap->bitmap, is_invers);
break;
}
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
#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, descriptor->id);
is_invers = 0;
@ -1364,7 +1364,7 @@ static pixman_image_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask, int
CANVAS_ERROR("invalid image type");
}
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
if (cache_me) {
canvas->bits_cache->ops->put(canvas->bits_cache, descriptor->id, surface);
}
@ -1658,7 +1658,7 @@ static void quic_usr_free(QuicUsrContext *usr, void *ptr)
free(ptr);
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
#ifdef SW_CANVAS_NO_CHUNKS
static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
{
@ -1736,7 +1736,7 @@ static int quic_usr_more_lines(QuicUsrContext *usr, uint8_t **lines)
return 0;
}
#ifdef CAIRO_CANVAS_ACCESS_TEST
#ifdef SW_CANVAS_ACCESS_TEST
static void __canvas_set_access_params(CanvasBase *canvas, unsigned long base, unsigned long max)
{
canvas->base = base;
@ -1747,7 +1747,7 @@ static void __canvas_set_access_params(CanvasBase *canvas, unsigned long base, u
static void canvas_base_destroy(CanvasBase *canvas)
{
quic_destroy(canvas->quic_data.quic);
#ifdef CAIRO_CANVAS_NO_CHUNKS
#ifdef SW_CANVAS_NO_CHUNKS
lz_destroy(canvas->lz_data.lz);
#endif
#ifdef GDI_CANVAS
@ -3226,15 +3226,15 @@ inline static void canvas_base_init_ops(SpiceCanvasOps *ops)
static int canvas_base_init(CanvasBase *canvas, SpiceCanvasOps *ops,
int width, int height, uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
)
@ -3247,13 +3247,13 @@ static int canvas_base_init(CanvasBase *canvas, SpiceCanvasOps *ops,
canvas->quic_data.usr.free = quic_usr_free;
canvas->quic_data.usr.more_space = quic_usr_more_space;
canvas->quic_data.usr.more_lines = quic_usr_more_lines;
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
canvas->quic_data.virt_mapping = virt_mapping;
#endif
if (!(canvas->quic_data.quic = quic_create(&canvas->quic_data.usr))) {
return 0;
}
#ifdef CAIRO_CANVAS_NO_CHUNKS
#ifdef SW_CANVAS_NO_CHUNKS
canvas->lz_data.usr.error = lz_usr_error;
canvas->lz_data.usr.warn = lz_usr_warn;
canvas->lz_data.usr.info = lz_usr_warn;
@ -3286,10 +3286,10 @@ static int canvas_base_init(CanvasBase *canvas, SpiceCanvasOps *ops,
canvas->width,
canvas->height);
#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
#if defined(SW_CANVAS_CACHE) || defined(SW_CANVAS_IMAGE_CACHE)
canvas->bits_cache = bits_cache;
#endif
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
canvas->palette_cache = palette_cache;
#endif

10
common/gdi_canvas.c
View File

@ -1837,7 +1837,7 @@ static void gdi_canvas_clear(SpiceCanvas *spice_canvas)
static void gdi_canvas_set_access_params(SpiceCanvas *spice_canvas, unsigned long base, unsigned long max)
{
#ifdef CAIRO_CANVAS_ACCESS_TEST
#ifdef SW_CANVAS_ACCESS_TEST
GdiCanvas *canvas = (GdiCanvas *)spice_canvas;
__canvas_set_access_params(&canvas->base, base, max);
#endif
@ -1858,10 +1858,10 @@ static SpiceCanvasOps gdi_canvas_ops;
SpiceCanvas *gdi_canvas_create(int width, int height,
HDC dc, RecurciveMutex* lock, uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
@ -1877,10 +1877,10 @@ SpiceCanvas *gdi_canvas_create(int width, int height,
canvas = spice_new0(GdiCanvas, 1);
init_ok = canvas_base_init(&canvas->base, &gdi_canvas_ops,
width, height, format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
,bits_cache
,palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, bits_cache
#endif
, surfaces

14
common/gl_canvas.c
View File

@ -812,7 +812,7 @@ static void gl_canvas_group_end(SpiceCanvas *spice_canvas)
static void gl_canvas_set_access_params(SpiceCanvas *spice_canvas, unsigned long base, unsigned long max)
{
#ifdef CAIRO_CANVAS_ACCESS_TEST
#ifdef SW_CANVAS_ACCESS_TEST
GLCanvas *canvas = (GLCanvas *)spice_canvas;
__canvas_set_access_params(&canvas->base, base, max);
#endif
@ -822,15 +822,15 @@ static int need_init = 1;
static SpiceCanvasOps gl_canvas_ops;
SpiceCanvas *gl_canvas_create(int width, int height, uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
)
@ -849,15 +849,15 @@ SpiceCanvas *gl_canvas_create(int width, int height, uint32_t format
canvas->private_data = NULL;
init_ok = canvas_base_init(&canvas->base, &gl_canvas_ops,
width, height, format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, bits_cache
, palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, bits_cache
#endif
, surfaces
, glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, virt_mapping
#endif
);

6
common/gl_canvas.h
View File

@ -22,15 +22,15 @@
#include "region.h"
SpiceCanvas *gl_canvas_create(int width, int height, uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
);

5
common/lz.h
View File

@ -62,9 +62,8 @@ void lz_decode_begin(LzContext *lz, uint8_t *io_ptr, unsigned int num_io_bytes,
Improtant: 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 neede and you shoud use stride to fix it.
Note: If the image is down to top, set the stride in the cairo surface to negative.
use cairo_image_surface_create_for_data to create the surface and
cairo_surface_set_user_data in order to free the data in the destroy callback.
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);

212
common/cairo_canvas.c → common/sw_canvas.c
View File

@ -17,7 +17,7 @@
*/
#include <math.h>
#include "cairo_canvas.h"
#include "sw_canvas.h"
#define CANVAS_USE_PIXMAN
#define CANVAS_SINGLE_INSTANCE
#include "canvas_base.c"
@ -25,16 +25,16 @@
#include "region.h"
#include "pixman_utils.h"
typedef struct CairoCanvas CairoCanvas;
typedef struct SwCanvas SwCanvas;
struct CairoCanvas {
struct SwCanvas {
CanvasBase base;
uint32_t *private_data;
int private_data_size;
pixman_image_t *image;
};
static pixman_image_t *canvas_get_pixman_brush(CairoCanvas *canvas,
static pixman_image_t *canvas_get_pixman_brush(SwCanvas *canvas,
SpiceBrush *brush)
{
switch (brush->type) {
@ -52,11 +52,11 @@ static pixman_image_t *canvas_get_pixman_brush(CairoCanvas *canvas,
return pixman_image_create_solid_fill(&c);
}
case SPICE_BRUSH_TYPE_PATTERN: {
CairoCanvas *surface_canvas;
SwCanvas *surface_canvas;
pixman_image_t* surface;
pixman_transform_t t;
surface_canvas = (CairoCanvas *)canvas_get_surface(&canvas->base, brush->u.pattern.pat);
surface_canvas = (SwCanvas *)canvas_get_surface(&canvas->base, brush->u.pattern.pat);
if (surface_canvas) {
surface = surface_canvas->image;
surface = pixman_image_ref(surface);
@ -79,18 +79,18 @@ static pixman_image_t *canvas_get_pixman_brush(CairoCanvas *canvas,
static pixman_image_t *get_image(SpiceCanvas *canvas)
{
CairoCanvas *cairo_canvas = (CairoCanvas *)canvas;
SwCanvas *sw_canvas = (SwCanvas *)canvas;
pixman_image_ref(cairo_canvas->image);
pixman_image_ref(sw_canvas->image);
return cairo_canvas->image;
return sw_canvas->image;
}
static void copy_region(SpiceCanvas *spice_canvas,
pixman_region32_t *dest_region,
int dx, int dy)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_box32_t *dest_rects;
int n_rects;
int i, j, end_line;
@ -166,7 +166,7 @@ static void fill_solid_spans(SpiceCanvas *spice_canvas,
int n_spans,
uint32_t color)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
int i;
for (i = 0; i < n_spans; i++) {
@ -183,7 +183,7 @@ static void fill_solid_rects(SpiceCanvas *spice_canvas,
int n_rects,
uint32_t color)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
int i;
for (i = 0; i < n_rects; i++) {
@ -201,7 +201,7 @@ static void fill_solid_rects_rop(SpiceCanvas *spice_canvas,
uint32_t color,
SpiceROP rop)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
int i;
for (i = 0; i < n_rects; i++) {
@ -219,7 +219,7 @@ static void __fill_tiled_rects(SpiceCanvas *spice_canvas,
pixman_image_t *tile,
int offset_x, int offset_y)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
int i;
for (i = 0; i < n_rects; i++) {
@ -246,8 +246,8 @@ static void fill_tiled_rects_from_surface(SpiceCanvas *spice_canvas,
SpiceCanvas *surface_canvas,
int offset_x, int offset_y)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__fill_tiled_rects(spice_canvas, rects, n_rects, cairo_surface_canvas->image, offset_x,
SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
__fill_tiled_rects(spice_canvas, rects, n_rects, sw_surface_canvas->image, offset_x,
offset_y);
}
@ -258,7 +258,7 @@ static void __fill_tiled_rects_rop(SpiceCanvas *spice_canvas,
int offset_x, int offset_y,
SpiceROP rop)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
int i;
for (i = 0; i < n_rects; i++) {
@ -287,8 +287,8 @@ static void fill_tiled_rects_rop_from_surface(SpiceCanvas *spice_canvas,
int offset_x, int offset_y,
SpiceROP rop)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__fill_tiled_rects_rop(spice_canvas, rects, n_rects, cairo_surface_canvas->image, offset_x,
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);
}
@ -348,7 +348,7 @@ static void __blit_image(SpiceCanvas *spice_canvas,
pixman_image_t *src_image,
int offset_x, int offset_y)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_box32_t *rects;
int n_rects, i;
@ -386,8 +386,8 @@ static void blit_image_from_surface(SpiceCanvas *spice_canvas,
SpiceCanvas *surface_canvas,
int offset_x, int offset_y)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__blit_image(spice_canvas, region, cairo_surface_canvas->image, offset_x, 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,
@ -396,7 +396,7 @@ static void __blit_image_rop(SpiceCanvas *spice_canvas,
int offset_x, int offset_y,
SpiceROP rop)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_box32_t *rects;
int n_rects, i;
@ -436,8 +436,8 @@ static void blit_image_rop_from_surface(SpiceCanvas *spice_canvas,
int offset_x, int offset_y,
SpiceROP rop)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__blit_image_rop(spice_canvas, region, cairo_surface_canvas->image, offset_x, offset_y, rop);
SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
__blit_image_rop(spice_canvas, region, sw_surface_canvas->image, offset_x, offset_y, rop);
}
@ -451,7 +451,7 @@ static void __scale_image(SpiceCanvas *spice_canvas,
int dest_width, int dest_height,
int scale_mode)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_transform_t transform;
double sx, sy;
@ -508,8 +508,8 @@ static void scale_image_from_surface(SpiceCanvas *spice_canvas,
int dest_width, int dest_height,
int scale_mode)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__scale_image(spice_canvas, region, cairo_surface_canvas->image, src_x, src_y, src_width,
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);
}
@ -522,7 +522,7 @@ static void __scale_image_rop(SpiceCanvas *spice_canvas,
int dest_width, int dest_height,
int scale_mode, SpiceROP rop)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_transform_t transform;
pixman_image_t *scaled;
pixman_box32_t *rects;
@ -605,12 +605,12 @@ static void scale_image_rop_from_surface(SpiceCanvas *spice_canvas,
int dest_width, int dest_height,
int scale_mode, SpiceROP rop)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__scale_image_rop(spice_canvas, region, cairo_surface_canvas->image, src_x, src_y, src_width,
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(CairoCanvas *canvas,
static pixman_image_t *canvas_get_as_surface(SwCanvas *canvas,
int with_alpha)
{
pixman_image_t *target;
@ -638,7 +638,7 @@ static void __blend_image(SpiceCanvas *spice_canvas,
int width, int height,
int overall_alpha)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_image_t *mask, *dest;
dest = canvas_get_as_surface(canvas, dest_has_alpha);
@ -699,10 +699,10 @@ static void blend_image_from_surface(SpiceCanvas *spice_canvas,
int width, int height,
int overall_alpha)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
pixman_image_t *src;
src = canvas_get_as_surface(cairo_surface_canvas, src_has_alpha);
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,
@ -721,7 +721,7 @@ static void __blend_scale_image(SpiceCanvas *spice_canvas,
int scale_mode,
int overall_alpha)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_transform_t transform;
pixman_image_t *mask, *dest;
double sx, sy;
@ -805,10 +805,10 @@ static void blend_scale_image_from_surface(SpiceCanvas *spice_canvas,
int scale_mode,
int overall_alpha)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
pixman_image_t *src;
src = canvas_get_as_surface(cairo_surface_canvas, src_has_alpha);
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);
@ -821,7 +821,7 @@ static void __colorkey_image(SpiceCanvas *spice_canvas,
int offset_x, int offset_y,
uint32_t transparent_color)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_box32_t *rects;
int n_rects, i;
@ -862,8 +862,8 @@ static void colorkey_image_from_surface(SpiceCanvas *spice_canvas,
int offset_x, int offset_y,
uint32_t transparent_color)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__colorkey_image(spice_canvas, region, cairo_surface_canvas->image, offset_x, offset_y,
SwCanvas *sw_surface_canvas = (SwCanvas *)surface_canvas;
__colorkey_image(spice_canvas, region, sw_surface_canvas->image, offset_x, offset_y,
transparent_color);
}
@ -876,7 +876,7 @@ static void __colorkey_scale_image(SpiceCanvas *spice_canvas,
int dest_width, int dest_height,
uint32_t transparent_color)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_transform_t transform;
pixman_image_t *scaled;
pixman_box32_t *rects;
@ -956,8 +956,8 @@ static void colorkey_scale_image_from_surface(SpiceCanvas *spice_canvas,
int dest_width, int dest_height,
uint32_t transparent_color)
{
CairoCanvas *cairo_surface_canvas = (CairoCanvas *)surface_canvas;
__colorkey_scale_image(spice_canvas, region, cairo_surface_canvas->image, src_x, src_y,
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);
}
@ -970,7 +970,7 @@ static void canvas_put_image(SpiceCanvas *spice_canvas,
uint32_t src_width, uint32_t src_height, int src_stride,
const QRegion *clip)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_image_t *src;
int dest_width;
int dest_height;
@ -1024,7 +1024,7 @@ static void canvas_put_image(SpiceCanvas *spice_canvas,
static void canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox,
SpiceClip *clip, SpiceText *text)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_region32_t dest_region;
pixman_image_t *str_mask, *brush;
SpiceString *str;
@ -1112,7 +1112,7 @@ static void canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox,
static void canvas_read_bits(SpiceCanvas *spice_canvas, uint8_t *dest,
int dest_stride, const SpiceRect *area)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
pixman_image_t* surface;
uint8_t *src;
int src_stride;
@ -1136,7 +1136,7 @@ static void canvas_read_bits(SpiceCanvas *spice_canvas, uint8_t *dest,
static void canvas_clear(SpiceCanvas *spice_canvas)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
spice_pixman_fill_rect(canvas->image,
0, 0,
pixman_image_get_width(canvas->image),
@ -1147,15 +1147,15 @@ static void canvas_clear(SpiceCanvas *spice_canvas)
static void canvas_set_access_params(SpiceCanvas *spice_canvas,
unsigned long base, unsigned long max)
{
#ifdef CAIRO_CANVAS_ACCESS_TEST
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
#ifdef SW_CANVAS_ACCESS_TEST
SwCanvas *canvas = (SwCanvas *)spice_canvas;
__canvas_set_access_params(&canvas->base, base, max);
#endif
}
static void canvas_destroy(SpiceCanvas *spice_canvas)
{
CairoCanvas *canvas = (CairoCanvas *)spice_canvas;
SwCanvas *canvas = (SwCanvas *)spice_canvas;
if (!canvas) {
return;
}
@ -1168,24 +1168,24 @@ static void canvas_destroy(SpiceCanvas *spice_canvas)
}
static int need_init = 1;
static SpiceCanvasOps cairo_canvas_ops;
static SpiceCanvasOps sw_canvas_ops;
static SpiceCanvas *canvas_create_common(pixman_image_t *image,
uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
)
{
CairoCanvas *canvas;
SwCanvas *canvas;
int init_ok;
if (need_init) {
@ -1194,20 +1194,20 @@ static SpiceCanvas *canvas_create_common(pixman_image_t *image,
spice_pixman_image_set_format(image,
spice_surface_format_to_pixman (format));
canvas = spice_new0(CairoCanvas, 1);
init_ok = canvas_base_init(&canvas->base, &cairo_canvas_ops,
canvas = spice_new0(SwCanvas, 1);
init_ok = canvas_base_init(&canvas->base, &sw_canvas_ops,
pixman_image_get_width (image),
pixman_image_get_height (image),
format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, bits_cache
, palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, bits_cache
#endif
, surfaces
, glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, virt_mapping
#endif
);
@ -1220,15 +1220,15 @@ static SpiceCanvas *canvas_create_common(pixman_image_t *image,
}
SpiceCanvas *canvas_create(int width, int height, uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
)
@ -1239,15 +1239,15 @@ SpiceCanvas *canvas_create(int width, int height, uint32_t format
width, height, NULL, 0);
return canvas_create_common(image, format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, bits_cache
, palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, bits_cache
#endif
, surfaces
, glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, virt_mapping
#endif
);
@ -1255,15 +1255,15 @@ SpiceCanvas *canvas_create(int width, int height, uint32_t format
SpiceCanvas *canvas_create_for_data(int width, int height, uint32_t format,
uint8_t *data, size_t stride
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
)
@ -1274,59 +1274,59 @@ SpiceCanvas *canvas_create_for_data(int width, int height, uint32_t format,
width, height, (uint32_t *)data, stride);
return canvas_create_common(image, format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, bits_cache
, palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, bits_cache
#endif
, surfaces
, glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, virt_mapping
#endif
);
}
void cairo_canvas_init() //unsafe global function
void sw_canvas_init() //unsafe global function
{
if (!need_init) {
return;
}
need_init = 0;
canvas_base_init_ops(&cairo_canvas_ops);
cairo_canvas_ops.draw_text = canvas_draw_text;
cairo_canvas_ops.put_image = canvas_put_image;
cairo_canvas_ops.clear = canvas_clear;
cairo_canvas_ops.read_bits = canvas_read_bits;
cairo_canvas_ops.set_access_params = canvas_set_access_params;
cairo_canvas_ops.destroy = canvas_destroy;
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.set_access_params = canvas_set_access_params;
sw_canvas_ops.destroy = canvas_destroy;
cairo_canvas_ops.fill_solid_spans = fill_solid_spans;
cairo_canvas_ops.fill_solid_rects = fill_solid_rects;
cairo_canvas_ops.fill_solid_rects_rop = fill_solid_rects_rop;
cairo_canvas_ops.fill_tiled_rects = fill_tiled_rects;
cairo_canvas_ops.fill_tiled_rects_from_surface = fill_tiled_rects_from_surface;
cairo_canvas_ops.fill_tiled_rects_rop = fill_tiled_rects_rop;
cairo_canvas_ops.fill_tiled_rects_rop_from_surface = fill_tiled_rects_rop_from_surface;
cairo_canvas_ops.blit_image = blit_image;
cairo_canvas_ops.blit_image_from_surface = blit_image_from_surface;
cairo_canvas_ops.blit_image_rop = blit_image_rop;
cairo_canvas_ops.blit_image_rop_from_surface = blit_image_rop_from_surface;
cairo_canvas_ops.scale_image = scale_image;
cairo_canvas_ops.scale_image_from_surface = scale_image_from_surface;
cairo_canvas_ops.scale_image_rop = scale_image_rop;
cairo_canvas_ops.scale_image_rop_from_surface = scale_image_rop_from_surface;
cairo_canvas_ops.blend_image = blend_image;
cairo_canvas_ops.blend_image_from_surface = blend_image_from_surface;
cairo_canvas_ops.blend_scale_image = blend_scale_image;
cairo_canvas_ops.blend_scale_image_from_surface = blend_scale_image_from_surface;
cairo_canvas_ops.colorkey_image = colorkey_image;
cairo_canvas_ops.colorkey_image_from_surface = colorkey_image_from_surface;
cairo_canvas_ops.colorkey_scale_image = colorkey_scale_image;
cairo_canvas_ops.colorkey_scale_image_from_surface = colorkey_scale_image_from_surface;
cairo_canvas_ops.copy_region = copy_region;
cairo_canvas_ops.get_image = get_image;
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();
}

14
common/cairo_canvas.h → common/sw_canvas.h
View File

@ -27,34 +27,34 @@
#include "region.h"
SpiceCanvas *canvas_create(int width, int height, uint32_t format
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
);
SpiceCanvas *canvas_create_for_data(int width, int height, uint32_t format, uint8_t *data, size_t stride
#ifdef CAIRO_CANVAS_CACHE
#ifdef SW_CANVAS_CACHE
, SpiceImageCache *bits_cache
, SpicePaletteCache *palette_cache
#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
#elif defined(SW_CANVAS_IMAGE_CACHE)
, SpiceImageCache *bits_cache
#endif
, SpiceImageSurfaces *surfaces
, SpiceGlzDecoder *glz_decoder
#ifndef CAIRO_CANVAS_NO_CHUNKS
#ifndef SW_CANVAS_NO_CHUNKS
, SpiceVirtMapping *virt_mapping
#endif
);
void cairo_canvas_init();
void sw_canvas_init();
#endif

8
server/Makefile.am
View File

@ -1,7 +1,7 @@
NULL =
INCLUDES = \
-I. \
-I. \
-I$(top_srcdir)/common \
-I$(top_srcdir)/common/linux \
$(PROTOCOL_CFLAGS) \
@ -12,14 +12,14 @@ INCLUDES = \
$(SSL_CFLAGS) \
$(CELT051_CFLAGS) \
$(SLIRP_CFLAGS) \
-DCAIRO_CANVAS_IMAGE_CACHE \
-DSW_CANVAS_IMAGE_CACHE \
-DRED_STATISTICS \
$(WARN_CFLAGS) \
$(VISIBILITY_HIDDEN_CFLAGS) \
$(NULL)
COMMON_SRCS = \
$(top_srcdir)/common/cairo_canvas.c \
COMMON_SRCS = \
$(top_srcdir)/common/sw_canvas.c \
$(top_srcdir)/common/pixman_utils.c \
$(top_srcdir)/common/lines.c \
$(top_srcdir)/common/gl_canvas.c \

6
server/red_dispatcher.c
View File

@ -28,7 +28,7 @@
#include "vd_interface.h"
#include "red_worker.h"
#include "quic.h"
#include "cairo_canvas.h"
#include "sw_canvas.h"
#include "gl_canvas.h"
#include "reds.h"
#include "red_dispatcher.h"
@ -131,7 +131,7 @@ typedef struct RendererInfo {
} RendererInfo;
static RendererInfo renderers_info[] = {
{RED_RENDERER_CAIRO, "cairo"},
{RED_RENDERER_SW, "sw"},
{RED_RENDERER_OGL_PBUF, "oglpbuf"},
{RED_RENDERER_OGL_PIXMAP, "oglpixmap"},
{RED_RENDERER_INVALID, NULL},
@ -483,7 +483,7 @@ RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface)
}
quic_init();
cairo_canvas_init();
sw_canvas_init();
gl_canvas_init();
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, channels) == -1) {

4
server/red_worker.c
View File

@ -36,7 +36,7 @@
#include "region.h"
#include <spice/protocol.h>
#include "red_worker.h"
#include "cairo_canvas.h"
#include "sw_canvas.h"
#include "gl_canvas.h"
#include "ogl_ctx.h"
#include "quic.h"
@ -7951,7 +7951,7 @@ static inline void *create_canvas_for_surface(RedWorker *worker, RedSurface *sur
SpiceCanvas *canvas;
switch (renderer) {
case RED_RENDERER_CAIRO:
case RED_RENDERER_SW:
canvas = canvas_create_for_data(width, height, format,
line_0, stride,
&worker->image_cache.base,

2
server/red_worker.h
View File

@ -77,7 +77,7 @@ typedef uint32_t RedWorkeMessage;
enum {
RED_RENDERER_INVALID,
RED_RENDERER_CAIRO,
RED_RENDERER_SW,
RED_RENDERER_OGL_PBUF,
RED_RENDERER_OGL_PIXMAP,
};

6
server/reds.c
View File

@ -81,7 +81,7 @@ static int spice_port = -1;
static int spice_secure_port = -1;
static char spice_addr[256];
static int spice_family = PF_UNSPEC;
static char *default_renderer = "cairo";
static char *default_renderer = "sw";
static int ticketing_enabled = 1; //Ticketing is enabled by default
static pthread_mutex_t *lock_cs;
@ -4038,7 +4038,7 @@ int __attribute__ ((visibility ("default"))) spice_parse_args(const char *in_arg
}
} while (args);
if (!renderers_opt && !red_dispatcher_add_renderer("cairo")) {
if (!renderers_opt && !red_dispatcher_add_renderer("sw")) {
goto error;
}
@ -4061,7 +4061,7 @@ const char *spice_usage_str[] __attribute__ ((visibility ("default"))) = {
"[,ic=on|auto_glz|auto_lz|quic|glz|lz|off]",
"[,playback-compression=on|off]",
"[,password=password][,disable-ticketing]",
"[,renderer=oglpbuf+oglpixmap+cairo]",
"[,renderer=oglpbuf+oglpixmap+sw]",
"[,sslkeys=key directory,sslcerts=certs directory,sslpassword=pem password,",
" sslciphersuite=cipher suite]",
"[,secure-channels=all|channel+channel+...]",