Rename symbols that were changed in spice-protocol

This is an automatic change using:
$ find -name "*.[ch]" | xargs ../spice-protocol/rename-identifiers.sh ../spice-protocol/renames
$ find -name "*.cpp" | xargs ../spice-protocol/rename-identifiers.sh ../spice-protocol/renames

84 files changed, 2580 insertions, 2580 deletions

diff --git a/client/application.cpp b/client/application.cpp
index 7655809d..cca7d434 100644
--- a/client/application.cpp
+++ b/client/application.cpp
@@ -154,9 +154,9 @@ private:
 private:
     AlphaImageFromRes _info_pixmap;
     AlphaImageFromRes _sticky_pixmap;
-    Point _info_pos;
-    Point _sticky_pos;
-    Rect _sticky_rect;
+    SpicePoint _info_pos;
+    SpicePoint _sticky_pos;
+    SpiceRect _sticky_rect;
     bool _sticky_on;
     RecurciveMutex _update_lock;
 };
@@ -172,7 +172,7 @@ InfoLayer::InfoLayer()
 void InfoLayer::draw_info(const QRegion& dest_region, RedDrawable& dest)
 {
     for (int i = 0; i < (int)dest_region.num_rects; i++) {
-        Rect* r = &dest_region.rects[i];
+        SpiceRect* r = &dest_region.rects[i];
         /* is rect inside sticky region or info region? */
         if (_sticky_on && rect_intersects(*r, _sticky_rect)) {
             dest.blend_pixels(_sticky_pixmap, r->left - _sticky_pos.x, r->top - _sticky_pos.y, *r);
@@ -194,9 +194,9 @@ void InfoLayer::set_info_mode()
 
     ASSERT(screen());
 
-    Point size = _info_pixmap.get_size();
-    Point screen_size = screen()->get_size();
-    Rect r;
+    SpicePoint size = _info_pixmap.get_size();
+    SpicePoint screen_size = screen()->get_size();
+    SpiceRect r;
 
     r.left = (screen_size.x - size.x) / 2;
     r.right = r.left + size.x;
@@ -211,8 +211,8 @@ void InfoLayer::set_info_mode()
 
 void InfoLayer::update_sticky_rect()
 {
-    Point size = _sticky_pixmap.get_size();
-    Point screen_size = screen()->get_size();
+    SpicePoint size = _sticky_pixmap.get_size();
+    SpicePoint screen_size = screen()->get_size();
 
     _sticky_pos.x = (screen_size.x - size.x) / 2;
     _sticky_pos.y = screen_size.y * 2 / 3;
@@ -315,7 +315,7 @@ enum AppCommands {
 Application::Application()
     : ProcessLoop (this)
     , _client (*this)
-    , _enabled_channels (RED_CHANNEL_END, true)
+    , _enabled_channels (SPICE_END_CHANNEL, true)
     , _main_screen (NULL)
     , _active (false)
     , _full_screen (false)
@@ -381,7 +381,7 @@ Application::Application()
     _gui_test_timer.reset(new TestTimer(*this));
     activate_interval_timer(*_gui_test_timer, 1000 * 30);
 #endif
-    for (int i = RED_CHANNEL_MAIN; i < RED_CHANNEL_END; i++) {
+    for (int i = SPICE_CHANNEL_MAIN; i < SPICE_END_CHANNEL; i++) {
         _peer_con_opt[i] = RedPeer::ConnectionOptions::CON_OP_BOTH;
     }
 }
@@ -579,10 +579,10 @@ RedScreen* Application::get_screen(int id)
 
     if (!(screen = _screens[id])) {
         Monitor* mon = find_monitor(id);
-        Point size;
+        SpicePoint size;
 
         if (_full_screen && mon) {
-            Point size = mon->get_size();
+            SpicePoint size = mon->get_size();
         } else {
             size.x = SCREEN_INIT_WIDTH;
             size.y = SCREEN_INIT_HEIGHT;
@@ -1310,10 +1310,10 @@ void Application::prepare_monitors()
         if (_screens[i] && (mon = _screens[i]->get_monitor())) {
 
             if (_screens[i]->is_size_locked()) {
-                Point size = _screens[i]->get_size();
+                SpicePoint size = _screens[i]->get_size();
                 mon->set_mode(size.x, size.y);
             } else {
-                Point size = mon->get_size();
+                SpicePoint size = mon->get_size();
                 _screens[i]->resize(size.x, size.y);
             }
         }
@@ -1644,13 +1644,13 @@ bool Application::set_channels_security(CmdLineParser& parser, bool on, char *va
 
     typedef std::map< std::string, int> ChannelsNamesMap;
     ChannelsNamesMap channels_names;
-    channels_names["main"] = RED_CHANNEL_MAIN;
-    channels_names["display"] = RED_CHANNEL_DISPLAY;
-    channels_names["inputs"] = RED_CHANNEL_INPUTS;
-    channels_names["cursor"] = RED_CHANNEL_CURSOR;
-    channels_names["playback"] = RED_CHANNEL_PLAYBACK;
-    channels_names["record"] = RED_CHANNEL_RECORD;
-    channels_names["tunnel"] = RED_CHANNEL_TUNNEL;
+    channels_names["main"] = SPICE_CHANNEL_MAIN;
+    channels_names["display"] = SPICE_CHANNEL_DISPLAY;
+    channels_names["inputs"] = SPICE_CHANNEL_INPUTS;
+    channels_names["cursor"] = SPICE_CHANNEL_CURSOR;
+    channels_names["playback"] = SPICE_CHANNEL_PLAYBACK;
+    channels_names["record"] = SPICE_CHANNEL_RECORD;
+    channels_names["tunnel"] = SPICE_CHANNEL_TUNNEL;
 
     if (!strcmp(val, "all")) {
         if ((val = parser.next_argument())) {
@@ -1711,12 +1711,12 @@ bool Application::set_enable_channels(CmdLineParser& parser, bool enable, char *
 {
     typedef std::map< std::string, int> ChannelsNamesMap;
     ChannelsNamesMap channels_names;
-    channels_names["display"] = RED_CHANNEL_DISPLAY;
-    channels_names["inputs"] = RED_CHANNEL_INPUTS;
-    channels_names["cursor"] = RED_CHANNEL_CURSOR;
-    channels_names["playback"] = RED_CHANNEL_PLAYBACK;
-    channels_names["record"] = RED_CHANNEL_RECORD;
-    channels_names["tunnel"] = RED_CHANNEL_TUNNEL;
+    channels_names["display"] = SPICE_CHANNEL_DISPLAY;
+    channels_names["inputs"] = SPICE_CHANNEL_INPUTS;
+    channels_names["cursor"] = SPICE_CHANNEL_CURSOR;
+    channels_names["playback"] = SPICE_CHANNEL_PLAYBACK;
+    channels_names["record"] = SPICE_CHANNEL_RECORD;
+    channels_names["tunnel"] = SPICE_CHANNEL_TUNNEL;
 
     if (!strcmp(val, "all")) {
         if ((val = parser.next_argument())) {
@@ -1750,27 +1750,27 @@ void Application::on_cmd_line_invalid_arg(const char* arg0, const char* what, co
 
 void Application::register_channels()
 {
-    if (_enabled_channels[RED_CHANNEL_DISPLAY]) {
+    if (_enabled_channels[SPICE_CHANNEL_DISPLAY]) {
         _client.register_channel_factory(DisplayChannel::Factory());
     }
 
-    if (_enabled_channels[RED_CHANNEL_CURSOR]) {
+    if (_enabled_channels[SPICE_CHANNEL_CURSOR]) {
         _client.register_channel_factory(CursorChannel::Factory());
     }
 
-    if (_enabled_channels[RED_CHANNEL_INPUTS]) {
+    if (_enabled_channels[SPICE_CHANNEL_INPUTS]) {
         _client.register_channel_factory(InputsChannel::Factory());
     }
 
-    if (_enabled_channels[RED_CHANNEL_PLAYBACK]) {
+    if (_enabled_channels[SPICE_CHANNEL_PLAYBACK]) {
         _client.register_channel_factory(PlaybackChannel::Factory());
     }
 
-    if (_enabled_channels[RED_CHANNEL_RECORD]) {
+    if (_enabled_channels[SPICE_CHANNEL_RECORD]) {
         _client.register_channel_factory(RecordChannel::Factory());
     }
 
-    if (_enabled_channels[RED_CHANNEL_TUNNEL]) {
+    if (_enabled_channels[SPICE_CHANNEL_TUNNEL]) {
         _client.register_channel_factory(TunnelChannel::Factory());
     }
 }
@@ -1833,7 +1833,7 @@ bool Application::process_cmd_line(int argc, char** argv)
     parser.add(SPICE_OPT_CANVAS_TYPE, "canvas-type", "set rendering canvas", "canvas_type", true);
     parser.set_multi(SPICE_OPT_CANVAS_TYPE, ',');
 
-    for (int i = RED_CHANNEL_MAIN; i < RED_CHANNEL_END; i++) {
+    for (int i = SPICE_CHANNEL_MAIN; i < SPICE_END_CHANNEL; i++) {
         _peer_con_opt[i] = RedPeer::ConnectionOptions::CON_OP_INVALID;
     }
 
diff --git a/client/application.h b/client/application.h
index 47cf29ef..b2a18d37 100644
--- a/client/application.h
+++ b/client/application.h
@@ -71,8 +71,8 @@ private:
 
 struct MonitorInfo {
     int depth;
-    Point size;
-    Point position;
+    SpicePoint size;
+    SpicePoint position;
 };
 
 class MonitorsQuery: public SyncEvent {
diff --git a/client/canvas.cpp b/client/canvas.cpp
index 6ce2af2b..04b0ce67 100644
--- a/client/canvas.cpp
+++ b/client/canvas.cpp
@@ -40,70 +40,70 @@ inline void Canvas::access_test(void *ptr, size_t size)
     }
 }
 
-void Canvas::localalize_ptr(ADDRESS* data)
+void Canvas::localalize_ptr(SPICE_ADDRESS* data)
 {
     if (*data) {
         *data += _base;
     }
 }
 
-void Canvas::localalize_image(ADDRESS* in_bitmap)
+void Canvas::localalize_image(SPICE_ADDRESS* in_bitmap)
 {
-    ImageDescriptor* image;
+    SpiceImageDescriptor* image;
 
     ASSERT(*in_bitmap);
     localalize_ptr(in_bitmap);
-    image = (ImageDescriptor*)GET_ADDRESS(*in_bitmap);
+    image = (SpiceImageDescriptor*)SPICE_GET_ADDRESS(*in_bitmap);
     switch (image->type) {
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)image;
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)image;
         localalize_ptr(&bitmap->bitmap.data);
-        if (bitmap->bitmap.palette && !(bitmap->bitmap.flags & BITMAP_PAL_FROM_CACHE)) {
+        if (bitmap->bitmap.palette && !(bitmap->bitmap.flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE)) {
             localalize_ptr(&bitmap->bitmap.palette);
         }
         break;
     }
-    case IMAGE_TYPE_LZ_PLT: {
-        LZ_PLTImage *lzImage = (LZ_PLTImage *)image;
+    case SPICE_IMAGE_TYPE_LZ_PLT: {
+        SpiceLZPLTImage *lzImage = (SpiceLZPLTImage *)image;
         ASSERT(lzImage->lz_plt.palette);
-        if (!(lzImage->lz_plt.flags & BITMAP_PAL_FROM_CACHE)) {
+        if (!(lzImage->lz_plt.flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE)) {
             localalize_ptr(&lzImage->lz_plt.palette);
         }
         break;
     }
-    case IMAGE_TYPE_LZ_RGB:
-    case IMAGE_TYPE_GLZ_RGB:
-    case IMAGE_TYPE_QUIC:
+    case SPICE_IMAGE_TYPE_LZ_RGB:
+    case SPICE_IMAGE_TYPE_GLZ_RGB:
+    case SPICE_IMAGE_TYPE_QUIC:
         break;
-    case IMAGE_TYPE_FROM_CACHE:
+    case SPICE_IMAGE_TYPE_FROM_CACHE:
         break;
     default:
         THROW("invalid image type %u", image->type);
     }
 }
 
-void Canvas::localalize_brush(Brush& brush)
+void Canvas::localalize_brush(SpiceBrush& brush)
 {
-    if (brush.type == BRUSH_TYPE_PATTERN) {
+    if (brush.type == SPICE_BRUSH_TYPE_PATTERN) {
         localalize_image(&brush.u.pattern.pat);
     }
 }
 
-void Canvas::localalize_attr(LineAttr& attr)
+void Canvas::localalize_attr(SpiceLineAttr& attr)
 {
     if (attr.style_nseg) {
         localalize_ptr(&attr.style);
     }
 }
 
-void Canvas::localalize_mask(QMask& mask)
+void Canvas::localalize_mask(SpiceQMask& mask)
 {
     if (mask.bitmap) {
         localalize_image(&mask.bitmap);
     }
 }
 
-void Canvas::begin_draw(RedDrawBase& base, int size, size_t min_size)
+void Canvas::begin_draw(SpiceMsgDisplayBase& base, int size, size_t min_size)
 {
     _base = (unsigned long)&base;
     _max = _base + size;
@@ -112,101 +112,101 @@ void Canvas::begin_draw(RedDrawBase& base, int size, size_t min_size)
     localalize_ptr(&base.clip.data);
 }
 
-void Canvas::draw_fill(RedFill& fill, int size)
+void Canvas::draw_fill(SpiceMsgDisplayDrawFill& fill, int size)
 {
-    begin_draw(fill.base, size, sizeof(RedFill));
+    begin_draw(fill.base, size, sizeof(SpiceMsgDisplayDrawFill));
     localalize_brush(fill.data.brush);
     localalize_mask(fill.data.mask);
     draw_fill(&fill.base.box, &fill.base.clip, &fill.data);
 }
 
-void Canvas::draw_text(RedText& text, int size)
+void Canvas::draw_text(SpiceMsgDisplayDrawText& text, int size)
 {
-    begin_draw(text.base, size, sizeof(RedText));
+    begin_draw(text.base, size, sizeof(SpiceMsgDisplayDrawText));
     localalize_brush(text.data.fore_brush);
     localalize_brush(text.data.back_brush);
     localalize_ptr(&text.data.str);
     draw_text(&text.base.box, &text.base.clip, &text.data);
 }
 
-void Canvas::draw_opaque(RedOpaque& opaque, int size)
+void Canvas::draw_opaque(SpiceMsgDisplayDrawOpaque& opaque, int size)
 {
-    begin_draw(opaque.base, size, sizeof(RedOpaque));
+    begin_draw(opaque.base, size, sizeof(SpiceMsgDisplayDrawOpaque));
     localalize_brush(opaque.data.brush);
     localalize_image(&opaque.data.src_bitmap);
     localalize_mask(opaque.data.mask);
     draw_opaque(&opaque.base.box, &opaque.base.clip, &opaque.data);
 }
 
-void Canvas::draw_copy(RedCopy& copy, int size)
+void Canvas::draw_copy(SpiceMsgDisplayDrawCopy& copy, int size)
 {
-    begin_draw(copy.base, size, sizeof(RedCopy));
+    begin_draw(copy.base, size, sizeof(SpiceMsgDisplayDrawCopy));
     localalize_image(&copy.data.src_bitmap);
     localalize_mask(copy.data.mask);
     draw_copy(&copy.base.box, &copy.base.clip, &copy.data);
 }
 
-void Canvas::draw_transparent(RedTransparent& transparent, int size)
+void Canvas::draw_transparent(SpiceMsgDisplayDrawTransparent& transparent, int size)
 {
-    begin_draw(transparent.base, size, sizeof(RedTransparent));
+    begin_draw(transparent.base, size, sizeof(SpiceMsgDisplayDrawTransparent));
     localalize_image(&transparent.data.src_bitmap);
     draw_transparent(&transparent.base.box, &transparent.base.clip, &transparent.data);
 }
 
-void Canvas::draw_alpha_blend(RedAlphaBlend& alpha_blend, int size)
+void Canvas::draw_alpha_blend(SpiceMsgDisplayDrawAlphaBlend& alpha_blend, int size)
 {
-    begin_draw(alpha_blend.base, size, sizeof(RedAlphaBlend));
+    begin_draw(alpha_blend.base, size, sizeof(SpiceMsgDisplayDrawAlphaBlend));
     localalize_image(&alpha_blend.data.src_bitmap);
     draw_alpha_blend(&alpha_blend.base.box, &alpha_blend.base.clip, &alpha_blend.data);
 }
 
-void Canvas::copy_bits(RedCopyBits& copy, int size)
+void Canvas::copy_bits(SpiceMsgDisplayCopyBits& copy, int size)
 {
-    begin_draw(copy.base, size, sizeof(RedCopyBits));
+    begin_draw(copy.base, size, sizeof(SpiceMsgDisplayCopyBits));
     copy_bits(&copy.base.box, &copy.base.clip, &copy.src_pos);
 }
 
-void Canvas::draw_blend(RedBlend& blend, int size)
+void Canvas::draw_blend(SpiceMsgDisplayDrawBlend& blend, int size)
 {
-    begin_draw(blend.base, size, sizeof(RedBlend));
+    begin_draw(blend.base, size, sizeof(SpiceMsgDisplayDrawBlend));
     localalize_image(&blend.data.src_bitmap);
     localalize_mask(blend.data.mask);
     draw_blend(&blend.base.box, &blend.base.clip, &blend.data);
 }
 
-void Canvas::draw_blackness(RedBlackness& blackness, int size)
+void Canvas::draw_blackness(SpiceMsgDisplayDrawBlackness& blackness, int size)
 {
-    begin_draw(blackness.base, size, sizeof(RedBlackness));
+    begin_draw(blackness.base, size, sizeof(SpiceMsgDisplayDrawBlackness));
     localalize_mask(blackness.data.mask);
     draw_blackness(&blackness.base.box, &blackness.base.clip, &blackness.data);
 }
 
-void Canvas::draw_whiteness(RedWhiteness& whiteness, int size)
+void Canvas::draw_whiteness(SpiceMsgDisplayDrawWhiteness& whiteness, int size)
 {
-    begin_draw(whiteness.base, size, sizeof(RedWhiteness));
+    begin_draw(whiteness.base, size, sizeof(SpiceMsgDisplayDrawWhiteness));
     localalize_mask(whiteness.data.mask);
     draw_whiteness(&whiteness.base.box, &whiteness.base.clip, &whiteness.data);
 }
 
-void Canvas::draw_invers(RedInvers& invers, int size)
+void Canvas::draw_invers(SpiceMsgDisplayDrawInvers& invers, int size)
 {
-    begin_draw(invers.base, size, sizeof(RedInvers));
+    begin_draw(invers.base, size, sizeof(SpiceMsgDisplayDrawInvers));
     localalize_mask(invers.data.mask);
     draw_invers(&invers.base.box, &invers.base.clip, &invers.data);
 }
 
-void Canvas::draw_rop3(RedRop3& rop3, int size)
+void Canvas::draw_rop3(SpiceMsgDisplayDrawRop3& rop3, int size)
 {
-    begin_draw(rop3.base, size, sizeof(RedRop3));
+    begin_draw(rop3.base, size, sizeof(SpiceMsgDisplayDrawRop3));
     localalize_brush(rop3.data.brush);
     localalize_image(&rop3.data.src_bitmap);
     localalize_mask(rop3.data.mask);
     draw_rop3(&rop3.base.box, &rop3.base.clip, &rop3.data);
 }
 
-void Canvas::draw_stroke(RedStroke& stroke, int size)
+void Canvas::draw_stroke(SpiceMsgDisplayDrawStroke& stroke, int size)
 {
-    begin_draw(stroke.base, size, sizeof(RedStroke));
+    begin_draw(stroke.base, size, sizeof(SpiceMsgDisplayDrawStroke));
     localalize_brush(stroke.data.brush);
     localalize_ptr(&stroke.data.path);
     localalize_attr(stroke.data.attr);
@@ -225,25 +225,25 @@ cairo_surface_t* Canvas::bits_cache_get(void *opaque, uint64_t id)
     return cache->get(id);
 }
 
-void Canvas::palette_cache_put(void *opaque, Palette *palette)
+void Canvas::palette_cache_put(void *opaque, SpicePalette *palette)
 {
     PaletteCache* cache = static_cast<PaletteCache*>(opaque);
     AutoRef<CachedPalette> cached_palette(new CachedPalette(palette));
     cache->add(palette->unique, *cached_palette);
 }
 
-Palette* Canvas::palette_cache_get(void *opaque, uint64_t id)
+SpicePalette* Canvas::palette_cache_get(void *opaque, uint64_t id)
 {
     PaletteCache* cache = static_cast<PaletteCache*>(opaque);
     return cache->get(id)->palette();
 }
 
-void Canvas::palette_cache_release(Palette* palette)
+void Canvas::palette_cache_release(SpicePalette* palette)
 {
     CachedPalette::unref(palette);
 }
 
-void Canvas::glz_decode(void *opaque, uint8_t *data, Palette *plt, void *usr_data)
+void Canvas::glz_decode(void *opaque, uint8_t *data, SpicePalette *plt, void *usr_data)
 {
     GlzDecoder* decoder = static_cast<GlzDecoder*>(opaque);
     decoder->decode(data, plt, usr_data);
diff --git a/client/canvas.h b/client/canvas.h
index f1fd9757..ed9d0e8a 100644
--- a/client/canvas.h
+++ b/client/canvas.h
@@ -56,13 +56,13 @@ typedef SharedCache<cairo_surface_t, PixmapCacheTreat, 1024> PixmapCache;
 
 class CachedPalette {
 public:
-    CachedPalette(Palette* palette)
+    CachedPalette(SpicePalette* palette)
         : _refs(1)
     {
-        int size = sizeof(Palette) + palette->num_ents * sizeof(uint32_t);
+        int size = sizeof(SpicePalette) + palette->num_ents * sizeof(uint32_t);
         CachedPalette **ptr = (CachedPalette **)new uint8_t[size + sizeof(CachedPalette *)];
         *ptr = this;
-        _palette = (Palette*)(ptr + 1);
+        _palette = (SpicePalette*)(ptr + 1);
         memcpy(_palette, palette, size);
     }
 
@@ -79,13 +79,13 @@ public:
         }
     }
 
-    static void unref(Palette *pal)
+    static void unref(SpicePalette *pal)
     {
         CachedPalette **ptr = (CachedPalette **)pal;
         (*(ptr - 1))->unref();
     }
 
-    Palette* palette() { return _palette;}
+    SpicePalette* palette() { return _palette;}
 
 private:
     ~CachedPalette()
@@ -95,7 +95,7 @@ private:
 
 private:
     int _refs;
-    Palette* _palette;
+    SpicePalette* _palette;
 };
 
 class PaletteCacheTreat {
@@ -188,25 +188,25 @@ public:
 
     virtual void clear() = 0;
 
-    void draw_fill(RedFill& fill, int size);
-    void draw_text(RedText& text, int size);
-    void draw_opaque(RedOpaque& opaque, int size);
-    void draw_copy(RedCopy& copy, int size);
-    void draw_transparent(RedTransparent& transparent, int size);
-    void draw_alpha_blend(RedAlphaBlend& alpha_blend, int size);
-    void copy_bits(RedCopyBits& copy_bits, int size);
-    void draw_blend(RedBlend& blend, int size);
-    void draw_blackness(RedBlackness& blackness, int size);
-    void draw_whiteness(RedWhiteness& whiteness, int size);
-    void draw_invers(RedInvers& invers, int size);
-    void draw_rop3(RedRop3& rop3, int size);
-    void draw_stroke(RedStroke& stroke, int size);
+    void draw_fill(SpiceMsgDisplayDrawFill& fill, int size);
+    void draw_text(SpiceMsgDisplayDrawText& text, int size);
+    void draw_opaque(SpiceMsgDisplayDrawOpaque& opaque, int size);
+    void draw_copy(SpiceMsgDisplayDrawCopy& copy, int size);
+    void draw_transparent(SpiceMsgDisplayDrawTransparent& transparent, int size);
+    void draw_alpha_blend(SpiceMsgDisplayDrawAlphaBlend& alpha_blend, int size);
+    void copy_bits(SpiceMsgDisplayCopyBits& copy_bits, int size);
+    void draw_blend(SpiceMsgDisplayDrawBlend& blend, int size);
+    void draw_blackness(SpiceMsgDisplayDrawBlackness& blackness, int size);
+    void draw_whiteness(SpiceMsgDisplayDrawWhiteness& whiteness, int size);
+    void draw_invers(SpiceMsgDisplayDrawInvers& invers, int size);
+    void draw_rop3(SpiceMsgDisplayDrawRop3& rop3, int size);
+    void draw_stroke(SpiceMsgDisplayDrawStroke& stroke, int size);
 
 #ifdef WIN32
     virtual void put_image(HDC dc, const PixmapHeader& image,
-                           const Rect& dest, const QRegion* clip) = 0;
+                           const SpiceRect& dest, const QRegion* clip) = 0;
 #else
-    virtual void put_image(const PixmapHeader& image, const Rect& dest,
+    virtual void put_image(const PixmapHeader& image, const SpiceRect& dest,
                            const QRegion* clip) = 0;
 #endif
 
@@ -214,39 +214,39 @@ public:
 
 protected:
     virtual void set_access_params(unsigned long base, unsigned long max) = 0;
-    virtual void draw_fill(Rect *bbox, Clip *clip, Fill *fill) = 0;
-    virtual void draw_copy(Rect *bbox, Clip *clip, Copy *copy) = 0;
-    virtual void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque) = 0;
-    virtual void copy_bits(Rect *bbox, Clip *clip, Point *src_pos) = 0;
-    virtual void draw_text(Rect *bbox, Clip *clip, Text *text) = 0;
-    virtual void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke) = 0;
-    virtual void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3) = 0;
-    virtual void draw_blend(Rect *bbox, Clip *clip, Blend *blend) = 0;
-    virtual void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness) = 0;
-    virtual void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness) = 0;
-    virtual void draw_invers(Rect *bbox, Clip *clip, Invers *invers) = 0;
-    virtual void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent) = 0;
-    virtual void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend) = 0;
+    virtual void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill) = 0;
+    virtual void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy) = 0;
+    virtual void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque) = 0;
+    virtual void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos) = 0;
+    virtual void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text) = 0;
+    virtual void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke) = 0;
+    virtual void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3) = 0;
+    virtual void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend) = 0;
+    virtual void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness) = 0;
+    virtual void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness) = 0;
+    virtual void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers) = 0;
+    virtual void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent) = 0;
+    virtual void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend) = 0;
 
     PixmapCache& pixmap_cache() { return _pixmap_cache;}
     PaletteCache& palette_cache() { return _palette_cache;}
     static void bits_cache_put(void *opaque, uint64_t id, cairo_surface_t *surface);
     static cairo_surface_t* bits_cache_get(void *opaque, uint64_t id);
-    static void palette_cache_put(void *opaque, Palette *palette);
-    static Palette* palette_cache_get(void *opaque, uint64_t id);
-    static void palette_cache_release(Palette* palette);
+    static void palette_cache_put(void *opaque, SpicePalette *palette);
+    static SpicePalette* palette_cache_get(void *opaque, uint64_t id);
+    static void palette_cache_release(SpicePalette* palette);
 
     GlzDecoder& glz_decoder() {return _glz_decoder;}
-    static void glz_decode(void *opaque, uint8_t *data, Palette *plt, void *usr_data);
+    static void glz_decode(void *opaque, uint8_t *data, SpicePalette *plt, void *usr_data);
 
 private:
     void access_test(void* ptr, size_t size);
-    void localalize_ptr(ADDRESS* data);
-    void localalize_image(ADDRESS* in_bitmap);
-    void localalize_brush(Brush& brush);
-    void localalize_attr(LineAttr& attr);
-    void localalize_mask(QMask& mask);
-    void begin_draw(RedDrawBase& base, int size, size_t min_size);
+    void localalize_ptr(SPICE_ADDRESS* data);
+    void localalize_image(SPICE_ADDRESS* in_bitmap);
+    void localalize_brush(SpiceBrush& brush);
+    void localalize_attr(SpiceLineAttr& attr);
+    void localalize_mask(SpiceQMask& mask);
+    void begin_draw(SpiceMsgDisplayBase& base, int size, size_t min_size);
 
 private:
     PixmapCache& _pixmap_cache;
diff --git a/client/cursor.cpp b/client/cursor.cpp
index 9bf8e9a6..7babdb90 100644
--- a/client/cursor.cpp
+++ b/client/cursor.cpp
@@ -20,7 +20,7 @@
 #include "utils.h"
 #include "debug.h"
 
-CursorData::CursorData(RedCursor& cursor, int data_size)
+CursorData::CursorData(SpiceCursor& cursor, int data_size)
     : _atomic (1)
     , _header (cursor.header)
     , _data (NULL)
@@ -30,31 +30,31 @@ CursorData::CursorData(RedCursor& cursor, int data_size)
     int expected_size = 0;
 
     switch (cursor.header.type) {
-    case CURSOR_TYPE_ALPHA:
+    case SPICE_CURSOR_TYPE_ALPHA:
         expected_size = (_header.width << 2) * _header.height;
         break;
-    case CURSOR_TYPE_MONO:
+    case SPICE_CURSOR_TYPE_MONO:
         expected_size = (ALIGN(_header.width, 8) >> 2) * _header.height;
         break;
-    case CURSOR_TYPE_COLOR4:
+    case SPICE_CURSOR_TYPE_COLOR4:
         expected_size = (ALIGN(_header.width, 2) >> 1) * _header.height;
         expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
         expected_size += 16 * sizeof(uint32_t);
         break;
-    case CURSOR_TYPE_COLOR8:
+    case SPICE_CURSOR_TYPE_COLOR8:
         expected_size = _header.width * _header.height;
         expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
         expected_size += 256 * sizeof(uint32_t);
         break;
-    case CURSOR_TYPE_COLOR16:
+    case SPICE_CURSOR_TYPE_COLOR16:
         expected_size = (_header.width << 1) * _header.height;
         expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
         break;
-    case CURSOR_TYPE_COLOR24:
+    case SPICE_CURSOR_TYPE_COLOR24:
         expected_size = (_header.width * 3) * _header.height;
         expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
         break;
-    case CURSOR_TYPE_COLOR32:
+    case SPICE_CURSOR_TYPE_COLOR32:
         expected_size = (_header.width << 2) * _header.height;
         expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
         break;
@@ -84,26 +84,26 @@ CursorData::~CursorData()
     delete[] _data;
 }
 
-int LocalCursor::get_size_bits(const CursorHeader& header, int& size)
+int LocalCursor::get_size_bits(const SpiceCursorHeader& header, int& size)
 {
     switch (header.type) {
-    case CURSOR_TYPE_ALPHA:
-    case CURSOR_TYPE_COLOR32:
+    case SPICE_CURSOR_TYPE_ALPHA:
+    case SPICE_CURSOR_TYPE_COLOR32:
         size = (header.width << 2) * header.height;
         return 32;
-    case CURSOR_TYPE_MONO:
+    case SPICE_CURSOR_TYPE_MONO:
         size = (ALIGN(header.width, 8) >> 3) * header.height;
         return 1;
-    case CURSOR_TYPE_COLOR4:
+    case SPICE_CURSOR_TYPE_COLOR4:
         size = (ALIGN(header.width, 2) >> 1) * header.height;
         return 4;
-    case CURSOR_TYPE_COLOR8:
+    case SPICE_CURSOR_TYPE_COLOR8:
         size = header.width * header.height;
         return 8;
-    case CURSOR_TYPE_COLOR16:
+    case SPICE_CURSOR_TYPE_COLOR16:
         size = (header.width << 1) * header.height;
         return 16;
-    case CURSOR_TYPE_COLOR24:
+    case SPICE_CURSOR_TYPE_COLOR24:
         size = (header.width * 3) * header.height;
         return 24;
     default:
diff --git a/client/cursor.h b/client/cursor.h
index c964fd40..cc64c720 100644
--- a/client/cursor.h
+++ b/client/cursor.h
@@ -32,7 +32,7 @@ class LocalCursor;
 
 class CursorData {
 public:
-    CursorData(RedCursor& cursor, int data_size);
+    CursorData(SpiceCursor& cursor, int data_size);
 
     CursorData *ref() { ++_atomic; return this;}
     void unref() {if (--_atomic == 0) delete this;}
@@ -40,7 +40,7 @@ public:
     CursorOpaque* get_opaque() { return _opaque;}
     void set_local(LocalCursor* local_cursor);
     LocalCursor* get_local() { return _local_cursor;}
-    const CursorHeader& header() const { return _header;}
+    const SpiceCursorHeader& header() const { return _header;}
     const uint8_t* data() const { return _data;}
 
 private:
@@ -48,7 +48,7 @@ private:
 
 private:
     AtomicCount _atomic;
-    CursorHeader _header;
+    SpiceCursorHeader _header;
     uint8_t* _data;
     CursorOpaque* _opaque;
     LocalCursor* _local_cursor;
@@ -63,7 +63,7 @@ public:
     void unref() { if (--_atomic == 0) delete this;}
 
 protected:
-    static int get_size_bits(const CursorHeader& header, int &size);
+    static int get_size_bits(const SpiceCursorHeader& header, int &size);
 
 private:
     AtomicCount _atomic;
diff --git a/client/cursor_channel.cpp b/client/cursor_channel.cpp
index 8a8fc658..30c52d9d 100644
--- a/client/cursor_channel.cpp
+++ b/client/cursor_channel.cpp
@@ -42,14 +42,14 @@ static inline uint8_t revers_bits(uint8_t byte)
 
 class NaitivCursor: public CursorOpaque {
 public:
-    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area) = 0;
+    virtual void draw(RedDrawable& dest, int x, int y, const SpiceRect& area) = 0;
 };
 
 class AlphaCursor: public NaitivCursor {
 public:
-    AlphaCursor(const CursorHeader& header, const uint8_t* data);
+    AlphaCursor(const SpiceCursorHeader& header, const uint8_t* data);
 
-    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+    virtual void draw(RedDrawable& dest, int x, int y, const SpiceRect& area);
 
 private:
     std::auto_ptr<RedPixmap> _pixmap;
@@ -57,9 +57,9 @@ private:
 
 class MonoCursor: public NaitivCursor {
 public:
-    MonoCursor(const CursorHeader& header, const uint8_t* data);
+    MonoCursor(const SpiceCursorHeader& header, const uint8_t* data);
 
-    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+    virtual void draw(RedDrawable& dest, int x, int y, const SpiceRect& area);
 
 private:
     std::auto_ptr<RedPixmap> _pixmap;
@@ -68,25 +68,25 @@ private:
 
 class UnsupportedCursor: public NaitivCursor {
 public:
-    UnsupportedCursor(const CursorHeader& header);
-    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+    UnsupportedCursor(const SpiceCursorHeader& header);
+    virtual void draw(RedDrawable& dest, int x, int y, const SpiceRect& area);
 
 private:
     int _hot_x;
     int _hot_y;
 };
 
-UnsupportedCursor::UnsupportedCursor(const CursorHeader& header)
+UnsupportedCursor::UnsupportedCursor(const SpiceCursorHeader& header)
     : _hot_x (header.hot_spot_x)
     , _hot_y (header.hot_spot_y)
 {
     LOG_WARN("Unsupported cursor %hu", header.type);
 }
 
-void UnsupportedCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+void UnsupportedCursor::draw(RedDrawable& dest, int x, int y, const SpiceRect& area)
 {
-    Rect dest_area;
-    Rect rect;
+    SpiceRect dest_area;
+    SpiceRect rect;
 
     dest_area.left = area.left;
     dest_area.right = area.right;
@@ -110,7 +110,7 @@ void UnsupportedCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
     dest.frame_rect(rect, rgb32_make(0, 0, 0));
 }
 
-AlphaCursor::AlphaCursor(const CursorHeader& header, const uint8_t* data)
+AlphaCursor::AlphaCursor(const SpiceCursorHeader& header, const uint8_t* data)
     : _pixmap (new RedPixmapCairo(header.width, header.height,
                                   RedPixmap::ARGB32, true, NULL, NULL))
 {
@@ -122,12 +122,12 @@ AlphaCursor::AlphaCursor(const CursorHeader& header, const uint8_t* data)
     }
 }
 
-void AlphaCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+void AlphaCursor::draw(RedDrawable& dest, int x, int y, const SpiceRect& area)
 {
     dest.blend_pixels(*_pixmap, area.left - x, area.top - y, area);
 }
 
-MonoCursor::MonoCursor(const CursorHeader& header, const uint8_t* data)
+MonoCursor::MonoCursor(const SpiceCursorHeader& header, const uint8_t* data)
     : _pixmap (NULL)
     , _height (header.height)
 {
@@ -154,7 +154,7 @@ MonoCursor::MonoCursor(const CursorHeader& header, const uint8_t* data)
     }
 }
 
-void MonoCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+void MonoCursor::draw(RedDrawable& dest, int x, int y, const SpiceRect& area)
 {
     dest.combine_pixels(*_pixmap, area.left - x, area.top - y, area, RedDrawable::OP_AND);
     dest.combine_pixels(*_pixmap, area.left - x, area.top - y + _height, area, RedDrawable::OP_XOR);
@@ -162,12 +162,12 @@ void MonoCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
 
 class ColorCursor: public NaitivCursor {
 public:
-    ColorCursor(const CursorHeader& header);
+    ColorCursor(const SpiceCursorHeader& header);
 
-    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+    virtual void draw(RedDrawable& dest, int x, int y, const SpiceRect& area);
 
 protected:
-    void init_pixels(const CursorHeader& header, const uint8_t* _pixels, const uint8_t *and_mask);
+    void init_pixels(const SpiceCursorHeader& header, const uint8_t* _pixels, const uint8_t *and_mask);
     virtual uint32_t get_pixel_color(const uint8_t *data, int row, int col) = 0;
 
 private:
@@ -175,7 +175,7 @@ private:
     std::auto_ptr<RedPixmap> _invers;
 };
 
-ColorCursor::ColorCursor(const CursorHeader& header)
+ColorCursor::ColorCursor(const SpiceCursorHeader& header)
     : _pixmap (new RedPixmapCairo(header.width, header.height,
                                   RedPixmap::ARGB32, true, NULL, NULL))
     , _invers (NULL)
@@ -185,7 +185,7 @@ ColorCursor::ColorCursor(const CursorHeader& header)
                                      true, pallete, NULL));
 }
 
-void ColorCursor::init_pixels(const CursorHeader& header, const uint8_t* pixels,
+void ColorCursor::init_pixels(const SpiceCursorHeader& header, const uint8_t* pixels,
                               const uint8_t *and_mask)
 {
     int mask_stride = ALIGN(header.width, 8) / 8;
@@ -217,7 +217,7 @@ void ColorCursor::init_pixels(const CursorHeader& header, const uint8_t* pixels,
     }
 }
 
-void ColorCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+void ColorCursor::draw(RedDrawable& dest, int x, int y, const SpiceRect& area)
 {
     dest.blend_pixels(*_pixmap, area.left - x, area.top - y, area);
     dest.combine_pixels(*_invers, area.left - x, area.top - y, area, RedDrawable::OP_XOR);
@@ -225,7 +225,7 @@ void ColorCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
 
 class ColorCursor32: public ColorCursor {
 public:
-    ColorCursor32(const CursorHeader& header, const uint8_t* data)
+    ColorCursor32(const SpiceCursorHeader& header, const uint8_t* data)
         : ColorCursor(header)
         , _src_stride (header.width * sizeof(uint32_t))
     {
@@ -244,7 +244,7 @@ private:
 
 class ColorCursor16: public ColorCursor {
 public:
-    ColorCursor16(const CursorHeader& header, const uint8_t* data)
+    ColorCursor16(const SpiceCursorHeader& header, const uint8_t* data)
         : ColorCursor(header)
         , _src_stride (header.width * sizeof(uint16_t))
     {
@@ -264,7 +264,7 @@ private:
 
 class ColorCursor4: public ColorCursor {
 public:
-    ColorCursor4(const CursorHeader& header, const uint8_t* data)
+    ColorCursor4(const SpiceCursorHeader& header, const uint8_t* data)
         : ColorCursor(header)
         , _src_stride (ALIGN(header.width, 2) >> 1)
         , _palette ((uint32_t*)(data + _src_stride * header.height))
@@ -300,7 +300,7 @@ public:
 
         virtual bool operator() (RedChannel& channel)
         {
-            if (channel.get_type() != RED_CHANNEL_DISPLAY ||
+            if (channel.get_type() != SPICE_CHANNEL_DISPLAY ||
                                                       channel.get_id() != _channel.get_id()) {
                 return true;
             }
@@ -350,14 +350,14 @@ private:
     CursorChannel& _channel;
 };
 
-class CursorHandler: public MessageHandlerImp<CursorChannel, RED_CURSOR_MESSAGES_END> {
+class CursorHandler: public MessageHandlerImp<CursorChannel, SPICE_MSG_END_CURSOR> {
 public:
     CursorHandler(CursorChannel& channel)
-        : MessageHandlerImp<CursorChannel, RED_CURSOR_MESSAGES_END>(channel) {}
+        : MessageHandlerImp<CursorChannel, SPICE_MSG_END_CURSOR>(channel) {}
 };
 
 CursorChannel::CursorChannel(RedClient& client, uint32_t id)
-    : RedChannel(client, RED_CHANNEL_CURSOR, id, new CursorHandler(*this))
+    : RedChannel(client, SPICE_CHANNEL_CURSOR, id, new CursorHandler(*this))
     , ScreenLayer(SCREEN_LAYER_CURSOR, false)
     , _cursor (NULL)
     , _cursor_visible (false)
@@ -365,27 +365,27 @@ CursorChannel::CursorChannel(RedClient& client, uint32_t id)
 {
     CursorHandler* handler = static_cast<CursorHandler*>(get_message_handler());
 
-    handler->set_handler(RED_MIGRATE, &CursorChannel::handle_migrate, 0);
-    handler->set_handler(RED_SET_ACK, &CursorChannel::handle_set_ack, sizeof(RedSetAck));
-    handler->set_handler(RED_PING, &CursorChannel::handle_ping, sizeof(RedPing));
-    handler->set_handler(RED_WAIT_FOR_CHANNELS, &CursorChannel::handle_wait_for_channels,
-                         sizeof(RedWaitForChannels));
-    handler->set_handler(RED_DISCONNECTING, &CursorChannel::handle_disconnect,
-                         sizeof(RedDisconnect));
-    handler->set_handler(RED_NOTIFY, &CursorChannel::handle_notify, sizeof(RedNotify));
-
-    handler->set_handler(RED_CURSOR_INIT, &CursorChannel::handle_init, sizeof(RedCursorInit));
-    handler->set_handler(RED_CURSOR_RESET, &CursorChannel::handle_reset, 0);
-    handler->set_handler(RED_CURSOR_SET, &CursorChannel::handle_cursor_set,
-                         sizeof(RedCursorSet));
-    handler->set_handler(RED_CURSOR_MOVE, &CursorChannel::handle_cursor_move,
-                         sizeof(RedCursorMove));
-    handler->set_handler(RED_CURSOR_HIDE, &CursorChannel::handle_cursor_hide, 0);
-    handler->set_handler(RED_CURSOR_TRAIL, &CursorChannel::handle_cursor_trail,
-                         sizeof(RedCursorTrail));
-    handler->set_handler(RED_CURSOR_INVAL_ONE, &CursorChannel::handle_inval_one,
-                         sizeof(RedInvalOne));
-    handler->set_handler(RED_CURSOR_INVAL_ALL, &CursorChannel::handle_inval_all, 0);
+    handler->set_handler(SPICE_MSG_MIGRATE, &CursorChannel::handle_migrate, 0);
+    handler->set_handler(SPICE_MSG_SET_ACK, &CursorChannel::handle_set_ack, sizeof(SpiceMsgSetAck));
+    handler->set_handler(SPICE_MSG_PING, &CursorChannel::handle_ping, sizeof(SpiceMsgPing));
+    handler->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &CursorChannel::handle_wait_for_channels,
+                         sizeof(SpiceMsgWaitForChannels));
+    handler->set_handler(SPICE_MSG_DISCONNECTING, &CursorChannel::handle_disconnect,
+                         sizeof(SpiceMsgDisconnect));
+    handler->set_handler(SPICE_MSG_NOTIFY, &CursorChannel::handle_notify, sizeof(SpiceMsgNotify));
+
+    handler->set_handler(SPICE_MSG_CURSOR_INIT, &CursorChannel::handle_init, sizeof(SpiceMsgCursorInit));
+    handler->set_handler(SPICE_MSG_CURSOR_RESET, &CursorChannel::handle_reset, 0);
+    handler->set_handler(SPICE_MSG_CURSOR_SET, &CursorChannel::handle_cursor_set,
+                         sizeof(SpiceMsgCursorSet));
+    handler->set_handler(SPICE_MSG_CURSOR_MOVE, &CursorChannel::handle_cursor_move,
+                         sizeof(SpiceMsgCursorMove));
+    handler->set_handler(SPICE_MSG_CURSOR_HIDE, &CursorChannel::handle_cursor_hide, 0);
+    handler->set_handler(SPICE_MSG_CURSOR_TRAIL, &CursorChannel::handle_cursor_trail,
+                         sizeof(SpiceMsgCursorTrail));
+    handler->set_handler(SPICE_MSG_CURSOR_INVAL_ONE, &CursorChannel::handle_inval_one,
+                         sizeof(SpiceMsgDisplayInvalOne));
+    handler->set_handler(SPICE_MSG_CURSOR_INVAL_ALL, &CursorChannel::handle_inval_all, 0);
 }
 
 CursorChannel::~CursorChannel()
@@ -456,25 +456,25 @@ void CursorChannel::create_native_cursor(CursorData* cursor)
     }
 
     switch (cursor->header().type) {
-    case CURSOR_TYPE_ALPHA:
+    case SPICE_CURSOR_TYPE_ALPHA:
         native_cursor = new AlphaCursor(cursor->header(), cursor->data());
         break;
-    case CURSOR_TYPE_COLOR32:
+    case SPICE_CURSOR_TYPE_COLOR32:
         native_cursor = new ColorCursor32(cursor->header(), cursor->data());
         break;
-    case CURSOR_TYPE_MONO:
+    case SPICE_CURSOR_TYPE_MONO:
         native_cursor = new MonoCursor(cursor->header(), cursor->data());
         break;
-    case CURSOR_TYPE_COLOR4:
+    case SPICE_CURSOR_TYPE_COLOR4:
         native_cursor = new ColorCursor4(cursor->header(), cursor->data());
         break;
-    case CURSOR_TYPE_COLOR8:
+    case SPICE_CURSOR_TYPE_COLOR8:
         native_cursor = new UnsupportedCursor(cursor->header());
         break;
-    case CURSOR_TYPE_COLOR16:
+    case SPICE_CURSOR_TYPE_COLOR16:
         native_cursor = new ColorCursor16(cursor->header(), cursor->data());
         break;
-    case CURSOR_TYPE_COLOR24:
+    case SPICE_CURSOR_TYPE_COLOR24:
         native_cursor = new UnsupportedCursor(cursor->header());
         break;
     default:
@@ -483,20 +483,20 @@ void CursorChannel::create_native_cursor(CursorData* cursor)
     cursor->set_opaque(native_cursor);
 }
 
-void CursorChannel::set_cursor(RedCursor& red_cursor, int data_size, int x, int y, bool visible)
+void CursorChannel::set_cursor(SpiceCursor& red_cursor, int data_size, int x, int y, bool visible)
 {
     CursorData *cursor;
 
-    if (red_cursor.flags & RED_CURSOR_NONE) {
+    if (red_cursor.flags & SPICE_CURSOR_FLAGS_NONE) {
         remove_cursor();
         return;
     }
 
-    if (red_cursor.flags & RED_CURSOR_FROM_CACHE) {
+    if (red_cursor.flags & SPICE_CURSOR_FLAGS_FROM_CACHE) {
         cursor = _cursor_cache.get(red_cursor.header.unique);
     } else {
         cursor = new CursorData(red_cursor, data_size);
-        if (red_cursor.flags & RED_CURSOR_CACHE_ME) {
+        if (red_cursor.flags & SPICE_CURSOR_FLAGS_CACHE_ME) {
             ASSERT(red_cursor.header.unique);
             _cursor_cache.add(red_cursor.header.unique, cursor);
         }
@@ -522,7 +522,7 @@ void CursorChannel::set_cursor(RedCursor& red_cursor, int data_size, int x, int
 
     update_display_cursor();
 
-    if (get_client().get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+    if (get_client().get_mouse_mode() == SPICE_MOUSE_MODE_SERVER) {
         if (_cursor_visible) {
             set_rect_area(_cursor_rect);
         } else {
@@ -554,11 +554,11 @@ void CursorChannel::detach_display()
 
 void CursorChannel::handle_init(RedPeer::InMessage *message)
 {
-    RedCursorInit *init = (RedCursorInit*)message->data();
+    SpiceMsgCursorInit *init = (SpiceMsgCursorInit*)message->data();
     attach_to_screen(get_client().get_application(), get_id());
     remove_cursor();
     _cursor_cache.clear();
-    set_cursor(init->cursor, message->size() - sizeof(RedCursorInit), init->position.x,
+    set_cursor(init->cursor, message->size() - sizeof(SpiceMsgCursorInit), init->position.x,
                init->position.y, init->visible != 0);
 }
 
@@ -571,14 +571,14 @@ void CursorChannel::handle_reset(RedPeer::InMessage *message)
 
 void CursorChannel::handle_cursor_set(RedPeer::InMessage* message)
 {
-    RedCursorSet* set = (RedCursorSet*)message->data();
-    set_cursor(set->cursor, message->size() - sizeof(RedCursorSet), set->postition.x,
+    SpiceMsgCursorSet* set = (SpiceMsgCursorSet*)message->data();
+    set_cursor(set->cursor, message->size() - sizeof(SpiceMsgCursorSet), set->postition.x,
                set->postition.y, set->visible != 0);
 }
 
 void CursorChannel::handle_cursor_move(RedPeer::InMessage* message)
 {
-    RedCursorMove* move = (RedCursorMove*)message->data();
+    SpiceMsgCursorMove* move = (SpiceMsgCursorMove*)message->data();
 
     if (!_cursor) {
         return;
@@ -596,7 +596,7 @@ void CursorChannel::handle_cursor_move(RedPeer::InMessage* message)
     _cursor_rect.bottom += dy;
     lock.unlock();
 
-    if (get_client().get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+    if (get_client().get_mouse_mode() == SPICE_MOUSE_MODE_SERVER) {
         set_rect_area(_cursor_rect);
         return;
     }
@@ -611,20 +611,20 @@ void CursorChannel::handle_cursor_hide(RedPeer::InMessage* message)
     _cursor_visible = false;
     update_display_cursor();
 
-    if (get_client().get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+    if (get_client().get_mouse_mode() == SPICE_MOUSE_MODE_SERVER) {
         clear_area();
     }
 }
 
 void CursorChannel::handle_cursor_trail(RedPeer::InMessage* message)
 {
-    RedCursorTrail* trail = (RedCursorTrail*)message->data();
+    SpiceMsgCursorTrail* trail = (SpiceMsgCursorTrail*)message->data();
     DBG(0, "length %u frequency %u", trail->length, trail->frequency)
 }
 
 void CursorChannel::handle_inval_one(RedPeer::InMessage* message)
 {
-    RedInvalOne* inval = (RedInvalOne*)message->data();
+    SpiceMsgDisplayInvalOne* inval = (SpiceMsgDisplayInvalOne*)message->data();
     _cursor_cache.remove(inval->id);
 }
 
@@ -637,7 +637,7 @@ void CursorChannel::on_mouse_mode_change()
 {
     Lock lock(_update_lock);
 
-    if (get_client().get_mouse_mode() == RED_MOUSE_MODE_CLIENT) {
+    if (get_client().get_mouse_mode() == SPICE_MOUSE_MODE_CLIENT) {
         clear_area();
         return;
     }
@@ -649,7 +649,7 @@ void CursorChannel::on_mouse_mode_change()
 
 class CursorFactory: public ChannelFactory {
 public:
-    CursorFactory() : ChannelFactory(RED_CHANNEL_CURSOR) {}
+    CursorFactory() : ChannelFactory(SPICE_CHANNEL_CURSOR) {}
     virtual RedChannel* construct(RedClient& client, uint32_t id)
     {
         return new CursorChannel(client, id);
diff --git a/client/cursor_channel.h b/client/cursor_channel.h
index 699d5197..5f5bdb17 100644
--- a/client/cursor_channel.h
+++ b/client/cursor_channel.h
@@ -63,7 +63,7 @@ private:
     static void create_native_cursor(CursorData* cursor);
 
     void update_display_cursor();
-    void set_cursor(RedCursor& red_cursor, int data_size, int x, int y, bool visible);
+    void set_cursor(SpiceCursor& red_cursor, int data_size, int x, int y, bool visible);
     void remove_cursor();
 
     virtual void copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc);
@@ -83,8 +83,8 @@ private:
 private:
     CursorCache _cursor_cache;
     CursorData* _cursor;
-    Point _hot_pos;
-    Rect _cursor_rect;
+    SpicePoint _hot_pos;
+    SpiceRect _cursor_rect;
     Mutex _update_lock;
     bool _cursor_visible;
     DisplayChannel* _display_channel;
diff --git a/client/display_channel.cpp b/client/display_channel.cpp
index 9d10bc7b..a60832aa 100644
--- a/client/display_channel.cpp
+++ b/client/display_channel.cpp
@@ -177,12 +177,12 @@ public:
     VideoStream(RedClient& client, Canvas& canvas, DisplayChannel& channel,
                 uint32_t codec_type, bool top_down, uint32_t stream_width,
                 uint32_t stream_height, uint32_t src_width, uint32_t src_height,
-                Rect* dest, int clip_type, uint32_t num_clip_rects, Rect* clip_rects);
+                SpiceRect* dest, int clip_type, uint32_t num_clip_rects, SpiceRect* clip_rects);
     ~VideoStream();
 
     void push_data(uint32_t mm_time, uint32_t length, uint8_t* data, uint32_t ped_size);
-    void set_clip(int type, uint32_t num_clip_rects, Rect* clip_rects);
-    const Rect& get_dest() {return _dest;}
+    void set_clip(int type, uint32_t num_clip_rects, SpiceRect* clip_rects);
+    const SpiceRect& get_dest() {return _dest;}
     void handle_update_mark(uint64_t update_mark);
     uint32_t handle_timer_update(uint32_t now);
 
@@ -208,7 +208,7 @@ private:
     int _stream_height;
     int _stride;
     bool _top_down;
-    Rect _dest;
+    SpiceRect _dest;
     QRegion _clip_region;
     QRegion* _clip;
 
@@ -277,8 +277,8 @@ static int create_bitmap(HDC *dc, HBITMAP *prev_bitmap,
 VideoStream::VideoStream(RedClient& client, Canvas& canvas, DisplayChannel& channel,
                          uint32_t codec_type, bool top_down, uint32_t stream_width,
                          uint32_t stream_height, uint32_t src_width, uint32_t src_height,
-                         Rect* dest, int clip_type, uint32_t num_clip_rects,
-                         Rect* clip_rects)
+                         SpiceRect* dest, int clip_type, uint32_t num_clip_rects,
+                         SpiceRect* clip_rects)
     : _client (client)
     , _canvas (canvas)
     , _channel (channel)
@@ -306,7 +306,7 @@ VideoStream::VideoStream(RedClient& client, Canvas& canvas, DisplayChannel& chan
     memset(_frames, 0, sizeof(_frames));
     region_init(&_clip_region);
     switch (codec_type) {
-    case RED_VIDEO_CODEC_TYPE_MJPEG:
+    case SPICE_VIDEO_CODEC_TYPE_MJPEG:
         type = CODEC_ID_MJPEG;
         break;
     default:
@@ -520,14 +520,14 @@ void VideoStream::push_data(uint32_t mm_time, uint32_t length, uint8_t* data, ui
     maintenance();
 }
 
-void VideoStream::set_clip(int type, uint32_t num_clip_rects, Rect* clip_rects)
+void VideoStream::set_clip(int type, uint32_t num_clip_rects, SpiceRect* clip_rects)
 {
-    if (type == CLIP_TYPE_NONE) {
+    if (type == SPICE_CLIP_TYPE_NONE) {
         _clip = NULL;
         return;
     }
 
-    ASSERT(type == CLIP_TYPE_RECTS)
+    ASSERT(type == SPICE_CLIP_TYPE_RECTS)
     region_clear(&_clip_region);
 
     for (unsigned int i = 0; i < num_clip_rects; i++) {
@@ -624,15 +624,15 @@ void ResetTimer::response(AbstractProcessLoop& events_loop)
     _client.deactivate_interval_timer(this);
 }
 
-class DisplayHandler: public MessageHandlerImp<DisplayChannel, RED_DISPLAY_MESSAGES_END> {
+class DisplayHandler: public MessageHandlerImp<DisplayChannel, SPICE_MSG_END_DISPLAY> {
 public:
     DisplayHandler(DisplayChannel& channel)
-        : MessageHandlerImp<DisplayChannel, RED_DISPLAY_MESSAGES_END>(channel) {}
+        : MessageHandlerImp<DisplayChannel, SPICE_MSG_END_DISPLAY>(channel) {}
 };
 
 DisplayChannel::DisplayChannel(RedClient& client, uint32_t id,
                                PixmapCache& pixmap_cache, GlzDecoderWindow& glz_window)
-    : RedChannel(client, RED_CHANNEL_DISPLAY, id, new DisplayHandler(*this),
+    : RedChannel(client, SPICE_CHANNEL_DISPLAY, id, new DisplayHandler(*this),
                  Platform::PRIORITY_LOW)
     , ScreenLayer (SCREEN_LAYER_DISPLAY, true)
     , _canvas (NULL)
@@ -655,37 +655,37 @@ DisplayChannel::DisplayChannel(RedClient& client, uint32_t id,
 {
     DisplayHandler* handler = static_cast<DisplayHandler*>(get_message_handler());
 
-    handler->set_handler(RED_MIGRATE, &DisplayChannel::handle_migrate, 0);
-    handler->set_handler(RED_SET_ACK, &DisplayChannel::handle_set_ack, sizeof(RedSetAck));
-    handler->set_handler(RED_PING, &DisplayChannel::handle_ping, sizeof(RedPing));
-    handler->set_handler(RED_WAIT_FOR_CHANNELS, &DisplayChannel::handle_wait_for_channels,
-                         sizeof(RedWaitForChannels));
-    handler->set_handler(RED_DISCONNECTING, &DisplayChannel::handle_disconnect,
-                         sizeof(RedDisconnect));
-    handler->set_handler(RED_NOTIFY, &DisplayChannel::handle_notify, sizeof(RedNotify));
+    handler->set_handler(SPICE_MSG_MIGRATE, &DisplayChannel::handle_migrate, 0);
+    handler->set_handler(SPICE_MSG_SET_ACK, &DisplayChannel::handle_set_ack, sizeof(SpiceMsgSetAck));
+    handler->set_handler(SPICE_MSG_PING, &DisplayChannel::handle_ping, sizeof(SpiceMsgPing));
+    handler->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &DisplayChannel::handle_wait_for_channels,
+                         sizeof(SpiceMsgWaitForChannels));
+    handler->set_handler(SPICE_MSG_DISCONNECTING, &DisplayChannel::handle_disconnect,
+                         sizeof(SpiceMsgDisconnect));
+    handler->set_handler(SPICE_MSG_NOTIFY, &DisplayChannel::handle_notify, sizeof(SpiceMsgNotify));
 
-    handler->set_handler(RED_DISPLAY_MODE, &DisplayChannel::handle_mode, sizeof(RedMode));
-    handler->set_handler(RED_DISPLAY_MARK, &DisplayChannel::handle_mark, 0);
-    handler->set_handler(RED_DISPLAY_RESET, &DisplayChannel::handle_reset, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_MODE, &DisplayChannel::handle_mode, sizeof(SpiceMsgDisplayMode));
+    handler->set_handler(SPICE_MSG_DISPLAY_MARK, &DisplayChannel::handle_mark, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_RESET, &DisplayChannel::handle_reset, 0);
 
-    handler->set_handler(RED_DISPLAY_INVAL_LIST,
+    handler->set_handler(SPICE_MSG_DISPLAY_INVAL_LIST,
                          &DisplayChannel::handle_inval_list,
-                         sizeof(RedResorceList));
-    handler->set_handler(RED_DISPLAY_INVAL_ALL_PIXMAPS,
+                         sizeof(SpiceResorceList));
+    handler->set_handler(SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS,
                          &DisplayChannel::handle_inval_all_pixmaps,
-                         sizeof(RedWaitForChannels));
-    handler->set_handler(RED_DISPLAY_INVAL_PALETTE,
-                         &DisplayChannel::handle_inval_palette, sizeof(RedInvalOne));
-    handler->set_handler(RED_DISPLAY_INVAL_ALL_PALETTES,
+                         sizeof(SpiceMsgWaitForChannels));
+    handler->set_handler(SPICE_MSG_DISPLAY_INVAL_PALETTE,
+                         &DisplayChannel::handle_inval_palette, sizeof(SpiceMsgDisplayInvalOne));
+    handler->set_handler(SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES,
                          &DisplayChannel::handle_inval_all_palettes, 0);
 
-    handler->set_handler(RED_DISPLAY_STREAM_CREATE, &DisplayChannel::handle_stream_create,
-                         sizeof(RedStreamCreate));
-    handler->set_handler(RED_DISPLAY_STREAM_CLIP, &DisplayChannel::handle_stream_clip,
-                         sizeof(RedStreamClip));
-    handler->set_handler(RED_DISPLAY_STREAM_DESTROY, &DisplayChannel::handle_stream_destroy,
-                         sizeof(RedStreamDestroy));
-    handler->set_handler(RED_DISPLAY_STREAM_DESTROY_ALL,
+    handler->set_handler(SPICE_MSG_DISPLAY_STREAM_CREATE, &DisplayChannel::handle_stream_create,
+                         sizeof(SpiceMsgDisplayStreamCreate));
+    handler->set_handler(SPICE_MSG_DISPLAY_STREAM_CLIP, &DisplayChannel::handle_stream_clip,
+                         sizeof(SpiceMsgDisplayStreamClip));
+    handler->set_handler(SPICE_MSG_DISPLAY_STREAM_DESTROY, &DisplayChannel::handle_stream_destroy,
+                         sizeof(SpiceMsgDisplayStreamDestroy));
+    handler->set_handler(SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL,
                          &DisplayChannel::handle_stream_destroy_all, 0);
 
     get_process_loop().add_trigger(_streams_trigger);
@@ -719,55 +719,55 @@ void DisplayChannel::set_draw_handlers()
 {
     DisplayHandler* handler = static_cast<DisplayHandler*>(get_message_handler());
 
-    handler->set_handler(RED_DISPLAY_COPY_BITS, &DisplayChannel::handle_copy_bits,
-                         sizeof(RedCopyBits));
-
-    handler->set_handler(RED_DISPLAY_DRAW_FILL, &DisplayChannel::handle_draw_fill,
-                         sizeof(RedFill));
-    handler->set_handler(RED_DISPLAY_DRAW_OPAQUE, &DisplayChannel::handle_draw_opaque,
-                         sizeof(RedOpaque));
-    handler->set_handler(RED_DISPLAY_DRAW_COPY, &DisplayChannel::handle_draw_copy,
-                         sizeof(RedCopy));
-    handler->set_handler(RED_DISPLAY_DRAW_BLEND, &DisplayChannel::handle_draw_blend,
-                         sizeof(RedBlend));
-    handler->set_handler(RED_DISPLAY_DRAW_BLACKNESS, &DisplayChannel::handle_draw_blackness,
-                         sizeof(RedBlackness));
-    handler->set_handler(RED_DISPLAY_DRAW_WHITENESS, &DisplayChannel::handle_draw_whiteness,
-                         sizeof(RedWhiteness));
-    handler->set_handler(RED_DISPLAY_DRAW_INVERS, &DisplayChannel::handle_draw_invers,
-                         sizeof(RedInvers));
-    handler->set_handler(RED_DISPLAY_DRAW_ROP3, &DisplayChannel::handle_draw_rop3,
-                         sizeof(RedRop3));
-    handler->set_handler(RED_DISPLAY_DRAW_STROKE, &DisplayChannel::handle_draw_stroke,
-                         sizeof(RedStroke));
-    handler->set_handler(RED_DISPLAY_DRAW_TEXT, &DisplayChannel::handle_draw_text,
-                         sizeof(RedText));
-    handler->set_handler(RED_DISPLAY_DRAW_TRANSPARENT,
-                         &DisplayChannel::handle_draw_transparent, sizeof(RedTransparent));
-    handler->set_handler(RED_DISPLAY_DRAW_ALPHA_BLEND,
-                         &DisplayChannel::handle_draw_alpha_blend, sizeof(RedAlphaBlend));
-    handler->set_handler(RED_DISPLAY_STREAM_DATA, &DisplayChannel::handle_stream_data,
-                         sizeof(RedStreamData));
+    handler->set_handler(SPICE_MSG_DISPLAY_COPY_BITS, &DisplayChannel::handle_copy_bits,
+                         sizeof(SpiceMsgDisplayCopyBits));
+
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_FILL, &DisplayChannel::handle_draw_fill,
+                         sizeof(SpiceMsgDisplayDrawFill));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_OPAQUE, &DisplayChannel::handle_draw_opaque,
+                         sizeof(SpiceMsgDisplayDrawOpaque));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_COPY, &DisplayChannel::handle_draw_copy,
+                         sizeof(SpiceMsgDisplayDrawCopy));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_BLEND, &DisplayChannel::handle_draw_blend,
+                         sizeof(SpiceMsgDisplayDrawBlend));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_BLACKNESS, &DisplayChannel::handle_draw_blackness,
+                         sizeof(SpiceMsgDisplayDrawBlackness));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_WHITENESS, &DisplayChannel::handle_draw_whiteness,
+                         sizeof(SpiceMsgDisplayDrawWhiteness));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_INVERS, &DisplayChannel::handle_draw_invers,
+                         sizeof(SpiceMsgDisplayDrawInvers));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_ROP3, &DisplayChannel::handle_draw_rop3,
+                         sizeof(SpiceMsgDisplayDrawRop3));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_STROKE, &DisplayChannel::handle_draw_stroke,
+                         sizeof(SpiceMsgDisplayDrawStroke));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_TEXT, &DisplayChannel::handle_draw_text,
+                         sizeof(SpiceMsgDisplayDrawText));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_TRANSPARENT,
+                         &DisplayChannel::handle_draw_transparent, sizeof(SpiceMsgDisplayDrawTransparent));
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND,
+                         &DisplayChannel::handle_draw_alpha_blend, sizeof(SpiceMsgDisplayDrawAlphaBlend));
+    handler->set_handler(SPICE_MSG_DISPLAY_STREAM_DATA, &DisplayChannel::handle_stream_data,
+                         sizeof(SpiceMsgDisplayStreamData));
 }
 
 void DisplayChannel::clear_draw_handlers()
 {
     DisplayHandler* handler = static_cast<DisplayHandler*>(get_message_handler());
 
-    handler->set_handler(RED_DISPLAY_COPY_BITS, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_FILL, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_OPAQUE, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_COPY, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_BLEND, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_BLACKNESS, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_WHITENESS, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_INVERS, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_ROP3, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_STROKE, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_TEXT, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_TRANSPARENT, NULL, 0);
-    handler->set_handler(RED_DISPLAY_DRAW_ALPHA_BLEND, NULL, 0);
-    handler->set_handler(RED_DISPLAY_STREAM_DATA, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_COPY_BITS, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_FILL, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_OPAQUE, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_COPY, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_BLEND, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_BLACKNESS, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_WHITENESS, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_INVERS, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_ROP3, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_STROKE, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_TEXT, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_TRANSPARENT, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND, NULL, 0);
+    handler->set_handler(SPICE_MSG_DISPLAY_STREAM_DATA, NULL, 0);
 }
 
 void DisplayChannel::copy_pixels(const QRegion& dest_region,
@@ -908,7 +908,7 @@ void DisplayChannel::on_mouse_button_release(int button, int buttons_state)
 {
     _buttons_state = buttons_state;
     if (_capture_mouse_mode) {
-        if (button == REDC_MOUSE_LBUTTON) {
+        if (button == SPICE_MOUSE_BUTTON_LEFT) {
             get_client().on_mouse_capture_trigger(*screen());
         }
         return;
@@ -1009,9 +1009,9 @@ public:
 
         virtual bool operator() (RedChannel& channel)
         {
-            if (channel.get_type() == RED_CHANNEL_CURSOR && channel.get_id() == _channel.get_id()) {
+            if (channel.get_type() == SPICE_CHANNEL_CURSOR && channel.get_id() == _channel.get_id()) {
                 static_cast<CursorChannel&>(channel).attach_display(&_channel);
-            } else if (channel.get_type() == RED_CHANNEL_INPUTS) {
+            } else if (channel.get_type() == SPICE_CHANNEL_INPUTS) {
                 _channel.attach_inputs(&static_cast<InputsChannel&>(channel));
             }
             return false;
@@ -1024,7 +1024,7 @@ public:
     virtual void response(AbstractProcessLoop& events_loop)
     {
         uint32_t mouse_mode = _channel.get_client().get_mouse_mode();
-        _channel._capture_mouse_mode =  (mouse_mode == RED_MOUSE_MODE_SERVER);
+        _channel._capture_mouse_mode =  (mouse_mode == SPICE_MOUSE_MODE_SERVER);
         AttachChannels for_each_func(_channel);
         _channel.get_client().for_each_channel(for_each_func);
     }
@@ -1046,7 +1046,7 @@ public:
 
         virtual bool operator() (RedChannel& channel)
         {
-            if (channel.get_type() == RED_CHANNEL_CURSOR && channel.get_id() == _channel.get_id()) {
+            if (channel.get_type() == SPICE_CHANNEL_CURSOR && channel.get_id() == _channel.get_id()) {
                 static_cast<CursorChannel&>(channel).detach_display();
                 return true;
             }
@@ -1069,8 +1069,8 @@ private:
 
 void DisplayChannel::on_connect()
 {
-    Message* message = new Message(REDC_DISPLAY_INIT, sizeof(RedcDisplayInit));
-    RedcDisplayInit* init = (RedcDisplayInit*)message->data();
+    Message* message = new Message(SPICE_MSGC_DISPLAY_INIT, sizeof(SpiceMsgcDisplayInit));
+    SpiceMsgcDisplayInit* init = (SpiceMsgcDisplayInit*)message->data();
     init->pixmap_cache_id = 1;
     init->pixmap_cache_size = get_client().get_pixmap_cache_size();
     init->glz_dictionary_id = 1;
@@ -1230,7 +1230,7 @@ void DisplayChannel::create_canvas(const std::vector<int>& canvas_types, int wid
 
 void DisplayChannel::handle_mode(RedPeer::InMessage* message)
 {
-    RedMode *mode = (RedMode *)message->data();
+    SpiceMsgDisplayMode *mode = (SpiceMsgDisplayMode *)message->data();
 
     _mark = false;
     attach_to_screen(get_client().get_application(), get_id());
@@ -1269,7 +1269,7 @@ void DisplayChannel::handle_mode(RedPeer::InMessage* message)
 void DisplayChannel::handle_mark(RedPeer::InMessage *message)
 {
     _mark = true;
-    Rect area;
+    SpiceRect area;
     area.top = area.left = 0;
     area.right = _x_res;
     area.bottom = _y_res;
@@ -1300,7 +1300,7 @@ void DisplayChannel::handle_reset(RedPeer::InMessage *message)
 
 void DisplayChannel::handle_inval_list(RedPeer::InMessage* message)
 {
-    RedResorceList *inval_list = (RedResorceList *)message->data();
+    SpiceResorceList *inval_list = (SpiceResorceList *)message->data();
 
     if (message->size() <
                         sizeof(*inval_list) + inval_list->count * sizeof(inval_list->resorces[0])) {
@@ -1308,7 +1308,7 @@ void DisplayChannel::handle_inval_list(RedPeer::InMessage* message)
     }
 
     for (int i = 0; i < inval_list->count; i++) {
-        if (inval_list->resorces[i].type != RED_RES_TYPE_PIXMAP) {
+        if (inval_list->resorces[i].type != SPICE_RES_TYPE_PIXMAP) {
             THROW("invalid res type");
         }
 
@@ -1318,7 +1318,7 @@ void DisplayChannel::handle_inval_list(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_inval_all_pixmaps(RedPeer::InMessage* message)
 {
-    RedWaitForChannels *wait = (RedWaitForChannels *)message->data();
+    SpiceMsgWaitForChannels *wait = (SpiceMsgWaitForChannels *)message->data();
     if (message->size() < sizeof(*wait) + wait->wait_count * sizeof(wait->wait_list[0])) {
         THROW("access violation");
     }
@@ -1328,7 +1328,7 @@ void DisplayChannel::handle_inval_all_pixmaps(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_inval_palette(RedPeer::InMessage* message)
 {
-    RedInvalOne* inval = (RedInvalOne*)message->data();
+    SpiceMsgDisplayInvalOne* inval = (SpiceMsgDisplayInvalOne*)message->data();
     _palette_cache.remove(inval->id);
 }
 
@@ -1337,35 +1337,35 @@ void DisplayChannel::handle_inval_all_palettes(RedPeer::InMessage* message)
     _palette_cache.clear();
 }
 
-void DisplayChannel::set_clip_rects(const Clip& clip, uint32_t& num_clip_rects,
-                                    Rect*& clip_rects, unsigned long addr_offset,
+void DisplayChannel::set_clip_rects(const SpiceClip& clip, uint32_t& num_clip_rects,
+                                    SpiceRect*& clip_rects, unsigned long addr_offset,
                                     uint8_t *min, uint8_t *max)
 {
     switch (clip.type) {
-    case CLIP_TYPE_RECTS: {
-        uint32_t* n = (uint32_t*)GET_ADDRESS(clip.data + addr_offset);
+    case SPICE_CLIP_TYPE_RECTS: {
+        uint32_t* n = (uint32_t*)SPICE_GET_ADDRESS(clip.data + addr_offset);
         if (n < (uint32_t*)min || n + 1 > (uint32_t*)max) {
             THROW("access violation");
         }
         num_clip_rects = *n;
-        clip_rects = (Rect *)(n + 1);
-        if (clip_rects + num_clip_rects > (Rect*)max) {
+        clip_rects = (SpiceRect *)(n + 1);
+        if (clip_rects + num_clip_rects > (SpiceRect*)max) {
             THROW("access violation");
         }
         break;
     }
-    case CLIP_TYPE_NONE:
+    case SPICE_CLIP_TYPE_NONE:
         num_clip_rects = 0;
         clip_rects = NULL;
         break;
-    case CLIP_TYPE_PATH:
+    case SPICE_CLIP_TYPE_PATH:
         THROW("unexpected clip type");
     }
 }
 
 void DisplayChannel::handle_stream_create(RedPeer::InMessage* message)
 {
-    RedStreamCreate* stream_create = (RedStreamCreate*)message->data();
+    SpiceMsgDisplayStreamCreate* stream_create = (SpiceMsgDisplayStreamCreate*)message->data();
 
     Lock lock(_streams_lock);
     if (_streams.size() <= stream_create->id) {
@@ -1377,13 +1377,13 @@ void DisplayChannel::handle_stream_create(RedPeer::InMessage* message)
     }
 
     uint32_t num_clip_rects;
-    Rect* clip_rects;
+    SpiceRect* clip_rects;
     set_clip_rects(stream_create->clip, num_clip_rects, clip_rects,
                    (unsigned long)message->data(), (uint8_t*)(stream_create + 1),
                    message->data() + message->size());
     _streams[stream_create->id] = new VideoStream(get_client(), *_canvas.get(),
                                                   *this, stream_create->codec_type,
-                                                  !!(stream_create->flags & STREAM_TOP_DOWN),
+                                                  !!(stream_create->flags & SPICE_STREAM_FLAGS_TOP_DOWN),
                                                   stream_create->stream_width,
                                                   stream_create->stream_height,
                                                   stream_create->src_width,
@@ -1398,14 +1398,14 @@ void DisplayChannel::handle_stream_create(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_stream_data(RedPeer::InMessage* message)
 {
-    RedStreamData* stream_data = (RedStreamData*)message->data();
+    SpiceMsgDisplayStreamData* stream_data = (SpiceMsgDisplayStreamData*)message->data();
     VideoStream* stream;
 
     if (stream_data->id >= _streams.size() || !(stream = _streams[stream_data->id])) {
         THROW("invalid stream");
     }
 
-    if (message->size() < sizeof(RedStreamData) + stream_data->data_size + stream_data->ped_size) {
+    if (message->size() < sizeof(SpiceMsgDisplayStreamData) + stream_data->data_size + stream_data->ped_size) {
         THROW("access violation");
     }
 
@@ -1415,16 +1415,16 @@ void DisplayChannel::handle_stream_data(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_stream_clip(RedPeer::InMessage* message)
 {
-    RedStreamClip* clip_data = (RedStreamClip*)message->data();
+    SpiceMsgDisplayStreamClip* clip_data = (SpiceMsgDisplayStreamClip*)message->data();
     VideoStream* stream;
     uint32_t num_clip_rects;
-    Rect* clip_rects;
+    SpiceRect* clip_rects;
 
     if (clip_data->id >= _streams.size() || !(stream = _streams[clip_data->id])) {
         THROW("invalid stream");
     }
 
-    if (message->size() < sizeof(RedStreamClip)) {
+    if (message->size() < sizeof(SpiceMsgDisplayStreamClip)) {
         THROW("access violation");
     }
     set_clip_rects(clip_data->clip, num_clip_rects, clip_rects,
@@ -1436,7 +1436,7 @@ void DisplayChannel::handle_stream_clip(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_stream_destroy(RedPeer::InMessage* message)
 {
-    RedStreamDestroy* stream_destroy = (RedStreamDestroy*)message->data();
+    SpiceMsgDisplayStreamDestroy* stream_destroy = (SpiceMsgDisplayStreamDestroy*)message->data();
 
     if (stream_destroy->id >= _streams.size() || !_streams[stream_destroy->id]) {
         THROW("invalid stream");
@@ -1477,7 +1477,7 @@ void DisplayChannel::handle_stream_destroy_all(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_copy_bits(RedPeer::InMessage* message)
 {
-    RedCopyBits* copy_bits = (RedCopyBits*)message->data();
+    SpiceMsgDisplayCopyBits* copy_bits = (SpiceMsgDisplayCopyBits*)message->data();
     PRE_DRAW;
     _canvas->copy_bits(*copy_bits, message->size());
     POST_DRAW;
@@ -1486,73 +1486,73 @@ void DisplayChannel::handle_copy_bits(RedPeer::InMessage* message)
 
 void DisplayChannel::handle_draw_fill(RedPeer::InMessage* message)
 {
-    RedFill* fill = (RedFill*)message->data();
+    SpiceMsgDisplayDrawFill* fill = (SpiceMsgDisplayDrawFill*)message->data();
     DRAW(fill);
 }
 
 void DisplayChannel::handle_draw_opaque(RedPeer::InMessage* message)
 {
-    RedOpaque* opaque = (RedOpaque*)message->data();
+    SpiceMsgDisplayDrawOpaque* opaque = (SpiceMsgDisplayDrawOpaque*)message->data();
     DRAW(opaque);
 }
 
 void DisplayChannel::handle_draw_copy(RedPeer::InMessage* message)
 {
-    RedCopy* copy = (RedCopy*)message->data();
+    SpiceMsgDisplayDrawCopy* copy = (SpiceMsgDisplayDrawCopy*)message->data();
     DRAW(copy);
 }
 
 void DisplayChannel::handle_draw_blend(RedPeer::InMessage* message)
 {
-    RedBlend* blend = (RedBlend*)message->data();
+    SpiceMsgDisplayDrawBlend* blend = (SpiceMsgDisplayDrawBlend*)message->data();
     DRAW(blend);
 }
 
 void DisplayChannel::handle_draw_blackness(RedPeer::InMessage* message)
 {
-    RedBlackness* blackness = (RedBlackness*)message->data();
+    SpiceMsgDisplayDrawBlackness* blackness = (SpiceMsgDisplayDrawBlackness*)message->data();
     DRAW(blackness);
 }
 
 void DisplayChannel::handle_draw_whiteness(RedPeer::InMessage* message)
 {
-    RedWhiteness* whiteness = (RedWhiteness*)message->data();
+    SpiceMsgDisplayDrawWhiteness* whiteness = (SpiceMsgDisplayDrawWhiteness*)message->data();
     DRAW(whiteness);
 }
 
 void DisplayChannel::handle_draw_invers(RedPeer::InMessage* message)
 {
-    RedInvers* invers = (RedInvers*)message->data();
+    SpiceMsgDisplayDrawInvers* invers = (SpiceMsgDisplayDrawInvers*)message->data();
     DRAW(invers);
 }
 
 void DisplayChannel::handle_draw_rop3(RedPeer::InMessage* message)
 {
-    RedRop3* rop3 = (RedRop3*)message->data();
+    SpiceMsgDisplayDrawRop3* rop3 = (SpiceMsgDisplayDrawRop3*)message->data();
     DRAW(rop3);
 }
 
 void DisplayChannel::handle_draw_stroke(RedPeer::InMessage* message)
 {
-    RedStroke* stroke = (RedStroke*)message->data();
+    SpiceMsgDisplayDrawStroke* stroke = (SpiceMsgDisplayDrawStroke*)message->data();
     DRAW(stroke);
 }
 
 void DisplayChannel::handle_draw_text(RedPeer::InMessage* message)
 {
-    RedText* text = (RedText*)message->data();
+    SpiceMsgDisplayDrawText* text = (SpiceMsgDisplayDrawText*)message->data();
     DRAW(text);
 }
 
 void DisplayChannel::handle_draw_transparent(RedPeer::InMessage* message)
 {
-    RedTransparent* transparent = (RedTransparent*)message->data();
+    SpiceMsgDisplayDrawTransparent* transparent = (SpiceMsgDisplayDrawTransparent*)message->data();
     DRAW(transparent);
 }
 
 void DisplayChannel::handle_draw_alpha_blend(RedPeer::InMessage* message)
 {
-    RedAlphaBlend* alpha_blend = (RedAlphaBlend*)message->data();
+    SpiceMsgDisplayDrawAlphaBlend* alpha_blend = (SpiceMsgDisplayDrawAlphaBlend*)message->data();
     DRAW(alpha_blend);
 }
 
@@ -1648,7 +1648,7 @@ void DisplayChannel::on_streams_trigger()
 
 class DisplayFactory: public ChannelFactory {
 public:
-    DisplayFactory() : ChannelFactory(RED_CHANNEL_DISPLAY) {}
+    DisplayFactory() : ChannelFactory(SPICE_CHANNEL_DISPLAY) {}
     virtual RedChannel* construct(RedClient& client, uint32_t id)
     {
         return new DisplayChannel(client, id,
diff --git a/client/display_channel.h b/client/display_channel.h
index e58be919..802898f5 100644
--- a/client/display_channel.h
+++ b/client/display_channel.h
@@ -166,7 +166,7 @@ private:
     void activate_streams_timer();
     void stream_update_request(uint32_t update_time);
 
-    static void set_clip_rects(const Clip& clip, uint32_t& num_clip_rects, Rect*& clip_rects,
+    static void set_clip_rects(const SpiceClip& clip, uint32_t& num_clip_rects, SpiceRect*& clip_rects,
                                unsigned long addr_offset, uint8_t *min, uint8_t *max);
 private:
     std::auto_ptr<Canvas> _canvas;
@@ -197,7 +197,7 @@ private:
     bool _capture_mouse_mode;
     InputsChannel* _inputs_channel;
 
-    Point _pointer_pos;
+    SpicePoint _pointer_pos;
     int _buttons_state;
 
     std::vector<VideoStream*> _streams;
diff --git a/client/glz_decode_tmpl.c b/client/glz_decode_tmpl.c
index 6942b73c..2c5d6a3c 100644
--- a/client/glz_decode_tmpl.c
+++ b/client/glz_decode_tmpl.c
@@ -175,7 +175,7 @@
    size should be in PIXEL */
 static size_t FNAME(decode)(GlzDecoderWindow &window, uint8_t* in_buf,
                             uint8_t *out_buf, int size,
-                            DecodedImageWinId image_win_id, Palette *plt,
+                            DecodedImageWinId image_win_id, SpicePalette *plt,
                             GlzDecoderDebug &debug_calls)
 {
     uint8_t      *ip = in_buf;
diff --git a/client/glz_decoder.cpp b/client/glz_decoder.cpp
index d5f5970d..0453aaae 100644
--- a/client/glz_decoder.cpp
+++ b/client/glz_decoder.cpp
@@ -188,7 +188,7 @@ typedef uint16_t rgb16_pixel_t;
 
 typedef size_t (*decode_function)(GlzDecoderWindow &window, uint8_t* in_buf,
                                   uint8_t *out_buf, int size,
-                                  DecodedImageWinId image_win_id, Palette *plt,
+                                  DecodedImageWinId image_win_id, SpicePalette *plt,
                                   GlzDecoderDebug  &debug_calls);
 
 // ordered according to LZ_IMAGE_TYPE
@@ -218,7 +218,7 @@ const decode_function DECODE_TO_SAME[] = {
     glz_rgb32_decode
 };
 
-void GlzDecoder::decode(uint8_t *data, Palette *palette, void *opaque_usr_info)
+void GlzDecoder::decode(uint8_t *data, SpicePalette *palette, void *opaque_usr_info)
 {
     int out_size;
     DecodedImageWinId image_window_id;
diff --git a/client/glz_decoder.h b/client/glz_decoder.h
index 98c15754..87cb747c 100644
--- a/client/glz_decoder.h
+++ b/client/glz_decoder.h
@@ -55,7 +55,7 @@ public:
     virtual ~GlzDecoder();
 
     /* Decodes the data and afterwards  calls GlzDecodeHandler::handle_decoded_image */
-    void decode(uint8_t *data, Palette *palette, void *opaque_usr_info);
+    void decode(uint8_t *data, SpicePalette *palette, void *opaque_usr_info);
 
 private:
     void decode_header();
diff --git a/client/gui/gui.cpp b/client/gui/gui.cpp
index 4a63d5a9..885f7422 100644
--- a/client/gui/gui.cpp
+++ b/client/gui/gui.cpp
@@ -81,7 +81,7 @@ public:
 
     class MyListItem : public CEGUI::ListboxTextItem {
     public:
-        MyListItem (const CEGUI::String& text)
+        MyListItem (const CEGUI::SpiceString& text)
             : CEGUI::ListboxTextItem(text)
         {
             setSelectionBrushImage("TaharezLook", "MultiListSelectionBrush");
@@ -257,7 +257,7 @@ private:
 
     class UndimInfo {
     public:
-        UndimInfo(const CEGUI::String& name, float alpha, bool inherits)
+        UndimInfo(const CEGUI::SpiceString& name, float alpha, bool inherits)
             : _name (name)
             , _alpha (alpha)
             , _inherits (inherits)
@@ -275,7 +275,7 @@ private:
         }
 
     private:
-        CEGUI::String _name;
+        CEGUI::SpiceString _name;
         float _alpha;
         bool _inherits;
 
@@ -736,7 +736,7 @@ ConnectingDialog::ConnectingDialog(GUI& gui)
         int y_pos = (MAIN_GUI_HEIGHT - CONNECTING_DIALOG_HEIGHT) / 2;
         set_win_pos(wnd, x_pos, y_pos);
         set_win_size(wnd, CONNECTING_DIALOG_WIDTH, CONNECTING_DIALOG_HEIGHT);
-        CEGUI::String text(res_get_string(STR_MESG_CONNECTING));
+        CEGUI::SpiceString text(res_get_string(STR_MESG_CONNECTING));
         wnd->setText(text + " " + application().get_host());
         wnd->setProperty("HorzFormatting", "LeftAligned");
         wnd->setProperty("VertFormatting", "TopAligned");
@@ -924,7 +924,7 @@ void GUI::init_cegui()
     _gui_system->setDefaultMouseCursor("TaharezLook", "MouseArrow");
     _gui_system->setDefaultTooltip("TaharezLook/Tooltip");
 
-    CEGUI::String font_name("DejaVuSans-10");
+    CEGUI::SpiceString font_name("DejaVuSans-10");
     CEGUI::Font* font;
 
     if (!CEGUI::FontManager::getSingleton().isFontPresent(font_name)) {
@@ -991,7 +991,7 @@ void GUI::update_layer_area()
         clear_area();
         return;
     }
-    Point screen_size = screen()->get_size();
+    SpicePoint screen_size = screen()->get_size();
 
     int dx = (screen_size.x - MAIN_GUI_WIDTH) / 2;
     int dy = (screen_size.y - MAIN_GUI_HEIGHT) / 2;
@@ -1010,8 +1010,8 @@ void GUI::update_layer_area()
             continue;
         }
 
-        CEGUI::Rect area = child->getPixelRect();
-        Rect r;
+        CEGUI::SpiceRect area = child->getPixelRect();
+        SpiceRect r;
         r.left = (int)area.d_left + dx;
         r.right = (int)area.d_right + dx;
         r.top = (int)area.d_top + dy;
@@ -1030,13 +1030,13 @@ void GUI::copy_pixels(const QRegion& dest_region, RedDrawable& dest)
     }
 
     for (int i = 0; i < (int)dest_region.num_rects; i++) {
-        Rect* r = &dest_region.rects[i];
+        SpiceRect* r = &dest_region.rects[i];
         _pixmap->copy_pixels(dest, r->left, r->top, *r);
     }
 
     _gui_system->renderGUI();
     for (int i = 0; i < (int)dest_region.num_rects; i++) {
-        Rect* r = &dest_region.rects[i];
+        SpiceRect* r = &dest_region.rects[i];
         dest.copy_pixels(*_pixmap, r->left, r->top, *r);
     }
 }
@@ -1145,23 +1145,23 @@ void GUI::on_mouse_button_press(int button, int buttons_state)
 {
     _app.set_key_handler(*this);
     switch (button) {
-    case REDC_MOUSE_LBUTTON:
+    case SPICE_MOUSE_BUTTON_LEFT:
         _gui_system->injectMouseButtonDown(CEGUI::LeftButton);
         break;
-    case REDC_MOUSE_MBUTTON:
+    case SPICE_MOUSE_BUTTON_MIDDLE:
         _gui_system->injectMouseButtonDown(CEGUI::MiddleButton);
         break;
-    case REDC_MOUSE_RBUTTON:
+    case SPICE_MOUSE_BUTTON_RIGHT:
         _gui_system->injectMouseButtonDown(CEGUI::RightButton);
         break;
-    case REDC_MOUSE_UBUTTON:
+    case SPICE_MOUSE_BUTTON_UP:
         _gui_system->injectMouseWheelChange(-1);
         break;
-    case REDC_MOUSE_DBUTTON:
+    case SPICE_MOUSE_BUTTON_DOWN:
         _gui_system->injectMouseWheelChange(1);
         break;
     default:
-        THROW("invalid RedButton %d", button);
+        THROW("invalid SpiceMouseButton %d", button);
     }
     conditional_update();
 }
@@ -1169,20 +1169,20 @@ void GUI::on_mouse_button_press(int button, int buttons_state)
 void GUI::on_mouse_button_release(int button, int buttons_state)
 {
     switch (button) {
-    case REDC_MOUSE_LBUTTON:
+    case SPICE_MOUSE_BUTTON_LEFT:
         _gui_system->injectMouseButtonUp(CEGUI::LeftButton);
         break;
-    case REDC_MOUSE_MBUTTON:
+    case SPICE_MOUSE_BUTTON_MIDDLE:
         _gui_system->injectMouseButtonUp(CEGUI::MiddleButton);
         break;
-    case REDC_MOUSE_RBUTTON:
+    case SPICE_MOUSE_BUTTON_RIGHT:
         _gui_system->injectMouseButtonUp(CEGUI::RightButton);
         break;
-    case REDC_MOUSE_UBUTTON:
-    case REDC_MOUSE_DBUTTON:
+    case SPICE_MOUSE_BUTTON_UP:
+    case SPICE_MOUSE_BUTTON_DOWN:
         break;
     default:
-        THROW("invalid RedButton %d", button);
+        THROW("invalid SpiceMouseButton %d", button);
     }
     conditional_update();
 }
diff --git a/client/gui/resource_provider.cpp b/client/gui/resource_provider.cpp
index 47f86a43..b194ea9e 100644
--- a/client/gui/resource_provider.cpp
+++ b/client/gui/resource_provider.cpp
@@ -19,9 +19,9 @@
 //{"; od -txC -v <in file name> | sed -e "s/^[0-9]*//" -e s"/ \([0-9a-f][0-9a-f]\)/0x\1,/g" -e"\$d"
 //| sed -e"\$s/,$/};/") > <out file name>.c
 
-void CEGUIResourceProvider::loadRawDataContainer(const CEGUI::String &filename,
+void CEGUIResourceProvider::loadRawDataContainer(const CEGUI::SpiceString &filename,
                                               CEGUI::RawDataContainer &output,
-                                              const CEGUI::String &resourceGroup)
+                                              const CEGUI::SpiceString &resourceGroup)
 {
     DBG(0, "%s", filename.c_str());
     if (strcmp(filename.c_str(), "TaharezLook.scheme") == 0) {
diff --git a/client/gui/resource_provider.h b/client/gui/resource_provider.h
index 1443abe4..b418c4dd 100644
--- a/client/gui/resource_provider.h
+++ b/client/gui/resource_provider.h
@@ -5,9 +5,9 @@
 
 class CEGUIResourceProvider: public CEGUI::ResourceProvider {
 public:
-    virtual void loadRawDataContainer(const CEGUI::String &filename,
+    virtual void loadRawDataContainer(const CEGUI::SpiceString &filename,
                                       CEGUI::RawDataContainer &output,
-                                      const CEGUI::String &resourceGroup);
+                                      const CEGUI::SpiceString &resourceGroup);
 
     virtual void unloadRawDataContainer(CEGUI::RawDataContainer& data);
 };
diff --git a/client/gui/softrenderer.cpp b/client/gui/softrenderer.cpp
index 87fffb8b..ca69cce4 100644
--- a/client/gui/softrenderer.cpp
+++ b/client/gui/softrenderer.cpp
@@ -62,11 +62,11 @@ void SoftRenderer::setupImageCodec()
     _destroy_image_codec = destroyImageCodec;
     _image_codec = createImageCodec();
 #else
-    String _default_codec_name(STRINGIZE(TGAImageCodec/*CEGUI_DEFAULT_IMAGE_CODEC*/));
+    SpiceString _default_codec_name(STRINGIZE(TGAImageCodec/*CEGUI_DEFAULT_IMAGE_CODEC*/));
     DynamicModule* module = NULL;
 
     try {
-        DynamicModule* module = new DynamicModule(String("CEGUI") + _default_codec_name);
+        DynamicModule* module = new DynamicModule(SpiceString("CEGUI") + _default_codec_name);
 
         _destroy_image_codec = (void(*)(ImageCodec*))module->getSymbolAddress("destroyImageCodec");
 
@@ -228,8 +228,8 @@ inline void SoftRenderer::setRGB(ColourI& dest, const colour& src)
     dest.a = uint8_t(src.getAlpha() * 255);
 }
 
-void SoftRenderer::addQuad(const Rect& dest_rect, float z, const Texture* texture,
-                   const Rect& texture_rect, const ColourRect& colours,
+void SoftRenderer::addQuad(const SpiceRect& dest_rect, float z, const Texture* texture,
+                   const SpiceRect& texture_rect, const ColourRect& colours,
                    QuadSplitMode quad_split_mode)
 {
     if (dest_rect.d_right <= dest_rect.d_left || dest_rect.d_bottom <= dest_rect.d_top) {
@@ -300,8 +300,8 @@ Texture* SoftRenderer::createTexture()
     return texture;
 }
 
-Texture* SoftRenderer::createTexture(const String& filename,
-                                     const String& resourceGroup)
+Texture* SoftRenderer::createTexture(const SpiceString& filename,
+                                     const SpiceString& resourceGroup)
 {
     SoftTexture* texture = new SoftTexture(this, filename, resourceGroup);
     _textures.push_back(texture);
@@ -354,9 +354,9 @@ Size SoftRenderer::getSize() const
     return Size((float)_width, (float)_height);
 }
 
-Rect SoftRenderer::getRect() const
+SpiceRect SoftRenderer::getRect() const
 {
-    return Rect(0, 0, (float)_width, (float)_height);
+    return SpiceRect(0, 0, (float)_width, (float)_height);
 }
 
 uint SoftRenderer::getHorzScreenDPI() const
diff --git a/client/gui/softrenderer.h b/client/gui/softrenderer.h
index 9fc1a29e..1cab0a24 100644
--- a/client/gui/softrenderer.h
+++ b/client/gui/softrenderer.h
@@ -24,8 +24,8 @@ namespace CEGUI
 
         void reset_surface(uint8_t* surface, uint width, uint height, uint stride);
 
-        virtual void addQuad(const Rect& dest_rect, float z, const Texture* tex,
-                            const Rect& texture_rect, const ColourRect& colours,
+        virtual void addQuad(const SpiceRect& dest_rect, float z, const Texture* tex,
+                            const SpiceRect& texture_rect, const ColourRect& colours,
                             QuadSplitMode quad_split_mode);
         virtual void doRender();
         virtual void clearRenderList();
@@ -33,8 +33,8 @@ namespace CEGUI
         virtual bool isQueueingEnabled() const;
 
         virtual Texture* createTexture();
-        virtual Texture* createTexture(const String& filename,
-                                       const String& resourceGroup);
+        virtual Texture* createTexture(const SpiceString& filename,
+                                       const SpiceString& resourceGroup);
         virtual Texture* createTexture(float size);
         virtual void destroyTexture(Texture* texture);
         virtual void destroyAllTextures();
@@ -43,7 +43,7 @@ namespace CEGUI
         virtual float getWidth() const;
         virtual float getHeight() const;
         virtual Size getSize() const;
-        virtual Rect getRect() const;
+        virtual SpiceRect getRect() const;
 
         virtual uint getHorzScreenDPI() const;
         virtual uint getVertScreenDPI() const;
diff --git a/client/gui/softtexture.cpp b/client/gui/softtexture.cpp
index 562edeab..983374ae 100644
--- a/client/gui/softtexture.cpp
+++ b/client/gui/softtexture.cpp
@@ -34,8 +34,8 @@ SoftTexture::SoftTexture(Renderer* owner, uint size)
 
 }
 
-SoftTexture::SoftTexture(Renderer* owner, const String& filename,
-                         const String& resourceGroup)
+SoftTexture::SoftTexture(Renderer* owner, const SpiceString& filename,
+                         const SpiceString& resourceGroup)
     : Texture (owner)
     , _surf (NULL)
     , _width (0)
@@ -57,7 +57,7 @@ void SoftTexture::freeSurf()
     _surf = NULL;
 }
 
-void SoftTexture::loadFromFile(const String& filename, const String& resourceGroup)
+void SoftTexture::loadFromFile(const SpiceString& filename, const SpiceString& resourceGroup)
 {
     freeSurf();
     SoftRenderer* renderer = static_cast<SoftRenderer*>(getRenderer());
diff --git a/client/gui/softtexture.h b/client/gui/softtexture.h
index 37617f29..f3797d9a 100644
--- a/client/gui/softtexture.h
+++ b/client/gui/softtexture.h
@@ -13,14 +13,14 @@ namespace CEGUI
     public:
         SoftTexture(Renderer* owner);
         SoftTexture(Renderer* owner, uint size);
-        SoftTexture(Renderer* owner, const String& filename,
-                    const String& resourceGroup);
+        SoftTexture(Renderer* owner, const SpiceString& filename,
+                    const SpiceString& resourceGroup);
         virtual ~SoftTexture();
 
         virtual ushort getWidth(void) const { return _width;}
         virtual ushort getHeight(void) const { return _height;}
 
-        virtual void loadFromFile(const String& filename, const String& resourceGroup);
+        virtual void loadFromFile(const SpiceString& filename, const SpiceString& resourceGroup);
         virtual void loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight,
                                     PixelFormat pixelFormat);
 
diff --git a/client/inputs_channel.cpp b/client/inputs_channel.cpp
index 1f24ffcf..2fa1e0d4 100644
--- a/client/inputs_channel.cpp
+++ b/client/inputs_channel.cpp
@@ -38,7 +38,7 @@ public:
 
         virtual bool operator() (RedChannel& channel)
         {
-            if (channel.get_type() == RED_CHANNEL_DISPLAY) {
+            if (channel.get_type() == SPICE_CHANNEL_DISPLAY) {
                 static_cast<DisplayChannel&>(channel).attach_inputs(&_channel);
             }
             return true;
@@ -83,7 +83,7 @@ public:
     public:
         virtual bool operator() (RedChannel& channel)
         {
-            if (channel.get_type() == RED_CHANNEL_DISPLAY) {
+            if (channel.get_type() == SPICE_CHANNEL_DISPLAY) {
                 static_cast<DisplayChannel&>(channel).detach_inputs();
             }
             return true;
@@ -114,7 +114,7 @@ private:
 
 MotionMessage::MotionMessage(InputsChannel& channel)
     : RedChannel::OutMessage()
-    , RedPeer::OutMessage(REDC_INPUTS_MOUSE_MOTION, sizeof(RedcMouseMotion))
+    , RedPeer::OutMessage(SPICE_MSGC_INPUTS_MOUSE_MOTION, sizeof(SpiceMsgcMouseMotion))
     , _channel (channel)
 {
 }
@@ -126,7 +126,7 @@ void MotionMessage::release()
 
 RedPeer::OutMessage& MotionMessage::peer_message()
 {
-    _channel.set_motion_event(*(RedcMouseMotion*)data());
+    _channel.set_motion_event(*(SpiceMsgcMouseMotion*)data());
     return *this;
 }
 
@@ -142,7 +142,7 @@ private:
 
 PositionMessage::PositionMessage(InputsChannel& channel)
     : RedChannel::OutMessage()
-    , RedPeer::OutMessage(REDC_INPUTS_MOUSE_POSITION, sizeof(RedcMousePosition))
+    , RedPeer::OutMessage(SPICE_MSGC_INPUTS_MOUSE_POSITION, sizeof(SpiceMsgcMousePosition))
     , _channel (channel)
 {
 }
@@ -154,18 +154,18 @@ void PositionMessage::release()
 
 RedPeer::OutMessage& PositionMessage::peer_message()
 {
-    _channel.set_position_event(*(RedcMousePosition*)data());
+    _channel.set_position_event(*(SpiceMsgcMousePosition*)data());
     return *this;
 }
 
-class InputsMessHandler: public MessageHandlerImp<InputsChannel, RED_INPUTS_MESSAGES_END> {
+class InputsMessHandler: public MessageHandlerImp<InputsChannel, SPICE_MSG_END_INPUTS> {
 public:
     InputsMessHandler(InputsChannel& channel)
-        : MessageHandlerImp<InputsChannel, RED_INPUTS_MESSAGES_END>(channel) {}
+        : MessageHandlerImp<InputsChannel, SPICE_MSG_END_INPUTS>(channel) {}
 };
 
 InputsChannel::InputsChannel(RedClient& client, uint32_t id)
-    : RedChannel(client, RED_CHANNEL_INPUTS, id, new InputsMessHandler(*this))
+    : RedChannel(client, SPICE_CHANNEL_INPUTS, id, new InputsMessHandler(*this))
     , _mouse_buttons_state (0)
     , _mouse_dx (0)
     , _mouse_dy (0)
@@ -177,19 +177,19 @@ InputsChannel::InputsChannel(RedClient& client, uint32_t id)
     , _active_modifiers_event (false)
 {
     InputsMessHandler* handler = static_cast<InputsMessHandler*>(get_message_handler());
-    handler->set_handler(RED_MIGRATE, &InputsChannel::handle_migrate, 0);
-    handler->set_handler(RED_SET_ACK, &InputsChannel::handle_set_ack, sizeof(RedSetAck));
-    handler->set_handler(RED_PING, &InputsChannel::handle_ping, sizeof(RedPing));
-    handler->set_handler(RED_WAIT_FOR_CHANNELS, &InputsChannel::handle_wait_for_channels,
-                         sizeof(RedWaitForChannels));
-    handler->set_handler(RED_DISCONNECTING, &InputsChannel::handle_disconnect,
-                         sizeof(RedDisconnect));
-    handler->set_handler(RED_NOTIFY, &InputsChannel::handle_notify, sizeof(RedNotify));
+    handler->set_handler(SPICE_MSG_MIGRATE, &InputsChannel::handle_migrate, 0);
+    handler->set_handler(SPICE_MSG_SET_ACK, &InputsChannel::handle_set_ack, sizeof(SpiceMsgSetAck));
+    handler->set_handler(SPICE_MSG_PING, &InputsChannel::handle_ping, sizeof(SpiceMsgPing));
+    handler->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &InputsChannel::handle_wait_for_channels,
+                         sizeof(SpiceMsgWaitForChannels));
+    handler->set_handler(SPICE_MSG_DISCONNECTING, &InputsChannel::handle_disconnect,
+                         sizeof(SpiceMsgDisconnect));
+    handler->set_handler(SPICE_MSG_NOTIFY, &InputsChannel::handle_notify, sizeof(SpiceMsgNotify));
 
-    handler->set_handler(RED_INPUTS_INIT, &InputsChannel::handle_init, sizeof(RedInputsInit));
-    handler->set_handler(RED_INPUTS_KEY_MODIFAIERS, &InputsChannel::handle_modifaiers,
-                         sizeof(RedKeyModifiers));
-    handler->set_handler(RED_INPUTS_MOUSE_MOTION_ACK, &InputsChannel::handle_motion_ack, 0);
+    handler->set_handler(SPICE_MSG_INPUTS_INIT, &InputsChannel::handle_init, sizeof(SpiceMsgInputsInit));
+    handler->set_handler(SPICE_MSG_INPUTS_KEY_MODIFIERS, &InputsChannel::handle_modifaiers,
+                         sizeof(SpiceMsgInputsKeyModifiers));
+    handler->set_handler(SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, &InputsChannel::handle_motion_ack, 0);
 }
 
 InputsChannel::~InputsChannel()
@@ -212,7 +212,7 @@ void InputsChannel::on_disconnect()
 
 void InputsChannel::handle_init(RedPeer::InMessage* message)
 {
-    RedInputsInit* init = (RedInputsInit*)message->data();
+    SpiceMsgInputsInit* init = (SpiceMsgInputsInit*)message->data();
     _modifiers = init->keyboard_modifiers;
     AutoRef<SetInputsHandlerEvent> set_handler_event(new SetInputsHandlerEvent(*this));
     get_client().push_event(*set_handler_event);
@@ -220,7 +220,7 @@ void InputsChannel::handle_init(RedPeer::InMessage* message)
 
 void InputsChannel::handle_modifaiers(RedPeer::InMessage* message)
 {
-    RedKeyModifiers* init = (RedKeyModifiers*)message->data();
+    SpiceMsgInputsKeyModifiers* init = (SpiceMsgInputsKeyModifiers*)message->data();
     _modifiers = init->modifiers;
     Lock lock(_update_modifiers_lock);
     if (_active_modifiers_event) {
@@ -234,20 +234,20 @@ void InputsChannel::handle_modifaiers(RedPeer::InMessage* message)
 void InputsChannel::handle_motion_ack(RedPeer::InMessage* message)
 {
     Lock lock(_motion_lock);
-    if (_motion_count < RED_MOTION_ACK_BUNCH) {
+    if (_motion_count < SPICE_INPUT_MOTION_ACK_BUNCH) {
         LOG_WARN("invalid motion count");
         _motion_count = 0;
     } else {
-        _motion_count -= RED_MOTION_ACK_BUNCH;
+        _motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH;
     }
     if (!_active_motion && (_mouse_dx || _mouse_dy || _display_id != -1)) {
         _active_motion = true;
         _motion_count++;
         switch (get_client().get_mouse_mode()) {
-        case RED_MOUSE_MODE_CLIENT:
+        case SPICE_MOUSE_MODE_CLIENT:
             post_message(new PositionMessage(*this));
             break;
-        case RED_MOUSE_MODE_SERVER:
+        case SPICE_MOUSE_MODE_SERVER:
             post_message(new MotionMessage(*this));
             break;
         default:
@@ -256,7 +256,7 @@ void InputsChannel::handle_motion_ack(RedPeer::InMessage* message)
     }
 }
 
-void InputsChannel::set_motion_event(RedcMouseMotion& motion)
+void InputsChannel::set_motion_event(SpiceMsgcMouseMotion& motion)
 {
     Lock lock(_motion_lock);
     motion.buttons_state = _mouse_buttons_state;
@@ -266,7 +266,7 @@ void InputsChannel::set_motion_event(RedcMouseMotion& motion)
     _active_motion = false;
 }
 
-void InputsChannel::set_position_event(RedcMousePosition& position)
+void InputsChannel::set_position_event(SpiceMsgcMousePosition& position)
 {
     Lock lock(_motion_lock);
     position.buttons_state = _mouse_buttons_state;
@@ -284,7 +284,7 @@ void InputsChannel::on_mouse_motion(int dx, int dy, int buttons_state)
     _mouse_buttons_state = buttons_state;
     _mouse_dx += dx;
     _mouse_dy += dy;
-    if (!_active_motion && _motion_count < RED_MOTION_ACK_BUNCH * 2) {
+    if (!_active_motion && _motion_count < SPICE_INPUT_MOTION_ACK_BUNCH * 2) {
         _active_motion = true;
         _motion_count++;
         post_message(new MotionMessage(*this));
@@ -298,7 +298,7 @@ void InputsChannel::on_mouse_position(int x, int y, int buttons_state, int displ
     _mouse_x = x;
     _mouse_y = y;
     _display_id = display_id;
-    if (!_active_motion && _motion_count < RED_MOTION_ACK_BUNCH * 2) {
+    if (!_active_motion && _motion_count < SPICE_INPUT_MOTION_ACK_BUNCH * 2) {
         _active_motion = true;
         _motion_count++;
         post_message(new PositionMessage(*this));
@@ -314,8 +314,8 @@ void InputsChannel::on_mouse_down(int button, int buttons_state)
 {
     Message* message;
 
-    message = new Message(REDC_INPUTS_MOUSE_PRESS, sizeof(RedcMouseRelease));
-    RedcMousePress* event = (RedcMousePress*)message->data();
+    message = new Message(SPICE_MSGC_INPUTS_MOUSE_PRESS, sizeof(SpiceMsgcMouseRelease));
+    SpiceMsgcMousePress* event = (SpiceMsgcMousePress*)message->data();
     event->button = button;
     event->buttons_state = buttons_state;
     post_message(message);
@@ -325,8 +325,8 @@ void InputsChannel::on_mouse_up(int button, int buttons_state)
 {
     Message* message;
 
-    message = new Message(REDC_INPUTS_MOUSE_RELEASE, sizeof(RedcMouseRelease));
-    RedcMouseRelease* event = (RedcMouseRelease*)message->data();
+    message = new Message(SPICE_MSGC_INPUTS_MOUSE_RELEASE, sizeof(SpiceMsgcMouseRelease));
+    SpiceMsgcMouseRelease* event = (SpiceMsgcMouseRelease*)message->data();
     event->button = button;
     event->buttons_state = buttons_state;
     post_message(message);
@@ -352,8 +352,8 @@ void InputsChannel::on_key_down(RedKey key)
         return;
     }
 
-    Message* message = new Message(REDC_INPUTS_KEY_DOWN, sizeof(RedcKeyDown));
-    RedcKeyDown* event = (RedcKeyDown*)message->data();
+    Message* message = new Message(SPICE_MSGC_INPUTS_KEY_DOWN, sizeof(SpiceMsgcKeyDown));
+    SpiceMsgcKeyDown* event = (SpiceMsgcKeyDown*)message->data();
     event->code = scan_code;
     post_message(message);
 }
@@ -366,8 +366,8 @@ void InputsChannel::on_key_up(RedKey key)
         return;
     }
 
-    Message* message = new Message(REDC_INPUTS_KEY_UP, sizeof(RedcKeyUp));
-    RedcKeyUp* event = (RedcKeyUp*)message->data();
+    Message* message = new Message(SPICE_MSGC_INPUTS_KEY_UP, sizeof(SpiceMsgcKeyUp));
+    SpiceMsgcKeyUp* event = (SpiceMsgcKeyUp*)message->data();
     event->code = scan_code;
     post_message(message);
 }
@@ -376,15 +376,15 @@ void InputsChannel::set_local_modifiers()
 {
     unsigned int modifiers = 0;
 
-    if (_modifiers & RED_SCROLL_LOCK_MODIFIER) {
+    if (_modifiers & SPICE_SCROLL_LOCK_MODIFIER) {
         modifiers |= Platform::SCROLL_LOCK_MODIFIER;
     }
 
-    if (_modifiers & RED_NUM_LOCK_MODIFIER) {
+    if (_modifiers & SPICE_NUM_LOCK_MODIFIER) {
         modifiers |= Platform::NUM_LOCK_MODIFIER;
     }
 
-    if (_modifiers & RED_CAPS_LOCK_MODIFIER) {
+    if (_modifiers & SPICE_CAPS_LOCK_MODIFIER) {
         modifiers |= Platform::CAPS_LOCK_MODIFIER;
     }
 
@@ -394,8 +394,8 @@ void InputsChannel::set_local_modifiers()
 void InputsChannel::on_focus_in()
 {
 #ifdef SYNC_REMOTH_MODIFIRES
-    Message* message = new Message(REDC_INPUTS_KEY_MODIFAIERS, sizeof(RedcKeyDown));
-    RedcKeyModifiers* modifiers = (RedcKeyModifiers*)message->data();
+    Message* message = new Message(SPICE_MSGC_INPUTS_KEY_MODIFIERS, sizeof(SpiceMsgcKeyDown));
+    SpiceMsgcKeyModifiers* modifiers = (SpiceMsgcKeyModifiers*)message->data();
     modifiers->modifiers = Platform::get_keyboard_lock_modifiers();
     post_message(message);
 #else
@@ -567,7 +567,7 @@ static InitGlobals init_globals;
 
 class InputsFactory: public ChannelFactory {
 public:
-    InputsFactory() : ChannelFactory(RED_CHANNEL_INPUTS) {}
+    InputsFactory() : ChannelFactory(SPICE_CHANNEL_INPUTS) {}
     virtual RedChannel* construct(RedClient& client, uint32_t id)
     {
         return new InputsChannel(client, id);
diff --git a/client/inputs_channel.h b/client/inputs_channel.h
index 66aea67a..f4f7ef84 100644
--- a/client/inputs_channel.h
+++ b/client/inputs_channel.h
@@ -45,8 +45,8 @@ protected:
     virtual void on_migrate();
 
 private:
-    void set_motion_event(RedcMouseMotion& motion_event);
-    void set_position_event(RedcMousePosition& position_event);
+    void set_motion_event(SpiceMsgcMouseMotion& motion_event);
+    void set_position_event(SpiceMsgcMousePosition& position_event);
     void set_local_modifiers();
 
     void handle_init(RedPeer::InMessage* message);
diff --git a/client/monitor.h b/client/monitor.h
index 7a4ba3f2..46b0a4e2 100644
--- a/client/monitor.h
+++ b/client/monitor.h
@@ -32,8 +32,8 @@ public:
     void set_mode(int width, int height);
     void restore();
     virtual int get_depth() = 0;
-    virtual Point get_position() = 0;
-    virtual Point get_size() const = 0;
+    virtual SpicePoint get_position() = 0;
+    virtual SpicePoint get_size() const = 0;
     virtual bool is_out_of_sync() = 0;
     virtual int get_screen_id() = 0;
 
diff --git a/client/pixels_source.h b/client/pixels_source.h
index 2fe09eab..e2fe0604 100644
--- a/client/pixels_source.h
+++ b/client/pixels_source.h
@@ -27,15 +27,15 @@ public:
     PixelsSource();
     virtual ~PixelsSource();
 
-    virtual Point get_size() = 0;
+    virtual SpicePoint get_size() = 0;
     void set_origin(int x, int y) { _origin.x = x; _origin.y = y;}
-    const Point& get_origin() { return _origin;}
+    const SpicePoint& get_origin() { return _origin;}
 
 protected:
     const uint8_t* get_opaque() const { return _opaque;}
 
 private:
-    Point _origin;
+    SpicePoint _origin;
     uint8_t _opaque[PIXELES_SOURCE_OPAQUE_SIZE];
 
     friend class RedDrawable;
@@ -45,14 +45,14 @@ class ImageFromRes: public PixelsSource {
 public:
     ImageFromRes(int res_id);
     virtual ~ImageFromRes();
-    virtual Point get_size();
+    virtual SpicePoint get_size();
 };
 
 class AlphaImageFromRes: public PixelsSource {
 public:
     AlphaImageFromRes(int res_id);
     virtual ~AlphaImageFromRes();
-    virtual Point get_size();
+    virtual SpicePoint get_size();
 };
 
 #endif
diff --git a/client/playback_channel.cpp b/client/playback_channel.cpp
index fd20b0ac..c696512a 100644
--- a/client/playback_channel.cpp
+++ b/client/playback_channel.cpp
@@ -137,17 +137,17 @@ static void end_wave()
 
 #endif
 
-class PlaybackHandler: public MessageHandlerImp<PlaybackChannel, RED_PLAYBACK_MESSAGES_END> {
+class PlaybackHandler: public MessageHandlerImp<PlaybackChannel, SPICE_MSG_END_PLAYBACK> {
 public:
     PlaybackHandler(PlaybackChannel& channel)
-        : MessageHandlerImp<PlaybackChannel, RED_PLAYBACK_MESSAGES_END>(channel) {}
+        : MessageHandlerImp<PlaybackChannel, SPICE_MSG_END_PLAYBACK>(channel) {}
 };
 
 PlaybackChannel::PlaybackChannel(RedClient& client, uint32_t id)
-    : RedChannel(client, RED_CHANNEL_PLAYBACK, id, new PlaybackHandler(*this),
+    : RedChannel(client, SPICE_CHANNEL_PLAYBACK, id, new PlaybackHandler(*this),
                  Platform::PRIORITY_HIGH)
     , _wave_player (NULL)
-    , _mode (RED_AUDIO_DATA_MODE_INVALD)
+    , _mode (SPICE_AUDIO_DATA_MODE_INVALD)
     , _celt_mode (NULL)
     , _celt_decoder (NULL)
     , _playing (false)
@@ -157,19 +157,19 @@ PlaybackChannel::PlaybackChannel(RedClient& client, uint32_t id)
 #endif
     PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
 
-    handler->set_handler(RED_MIGRATE, &PlaybackChannel::handle_migrate, 0);
-    handler->set_handler(RED_SET_ACK, &PlaybackChannel::handle_set_ack, sizeof(RedSetAck));
-    handler->set_handler(RED_PING, &PlaybackChannel::handle_ping, sizeof(RedPing));
-    handler->set_handler(RED_WAIT_FOR_CHANNELS, &PlaybackChannel::handle_wait_for_channels,
-                         sizeof(RedWaitForChannels));
-    handler->set_handler(RED_DISCONNECTING, &PlaybackChannel::handle_disconnect,
-                         sizeof(RedDisconnect));
-    handler->set_handler(RED_NOTIFY, &PlaybackChannel::handle_notify, sizeof(RedNotify));
+    handler->set_handler(SPICE_MSG_MIGRATE, &PlaybackChannel::handle_migrate, 0);
+    handler->set_handler(SPICE_MSG_SET_ACK, &PlaybackChannel::handle_set_ack, sizeof(SpiceMsgSetAck));
+    handler->set_handler(SPICE_MSG_PING, &PlaybackChannel::handle_ping, sizeof(SpiceMsgPing));
+    handler->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &PlaybackChannel::handle_wait_for_channels,
+                         sizeof(SpiceMsgWaitForChannels));
+    handler->set_handler(SPICE_MSG_DISCONNECTING, &PlaybackChannel::handle_disconnect,
+                         sizeof(SpiceMsgDisconnect));
+    handler->set_handler(SPICE_MSG_NOTIFY, &PlaybackChannel::handle_notify, sizeof(SpiceMsgNotify));
 
-    handler->set_handler(RED_PLAYBACK_MODE, &PlaybackChannel::handle_mode,
-                         sizeof(RedPlaybackMode));
+    handler->set_handler(SPICE_MSG_PLAYBACK_MODE, &PlaybackChannel::handle_mode,
+                         sizeof(SpiceMsgPlaybackMode));
 
-    set_capability(RED_PLAYBACK_CAP_CELT_0_5_1);
+    set_capability(SPICE_PLAYBACK_CAP_CELT_0_5_1);
 }
 
 PlaybackChannel::~PlaybackChannel(void)
@@ -194,10 +194,10 @@ void PlaybackChannel::set_data_handler()
 {
     PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
 
-    if (_mode == RED_AUDIO_DATA_MODE_RAW) {
-        handler->set_handler(RED_PLAYBACK_DATA, &PlaybackChannel::handle_raw_data, 0);
-    } else if (_mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
-        handler->set_handler(RED_PLAYBACK_DATA, &PlaybackChannel::handle_celt_data, 0);
+    if (_mode == SPICE_AUDIO_DATA_MODE_RAW) {
+        handler->set_handler(SPICE_MSG_PLAYBACK_DATA, &PlaybackChannel::handle_raw_data, 0);
+    } else if (_mode == SPICE_AUDIO_DATA_MODE_CELT_0_5_1) {
+        handler->set_handler(SPICE_MSG_PLAYBACK_DATA, &PlaybackChannel::handle_celt_data, 0);
     } else {
         THROW("invalid mode");
     }
@@ -205,9 +205,9 @@ void PlaybackChannel::set_data_handler()
 
 void PlaybackChannel::handle_mode(RedPeer::InMessage* message)
 {
-    RedPlaybackMode* playbacke_mode = (RedPlaybackMode*)message->data();
-    if (playbacke_mode->mode != RED_AUDIO_DATA_MODE_RAW &&
-        playbacke_mode->mode != RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+    SpiceMsgPlaybackMode* playbacke_mode = (SpiceMsgPlaybackMode*)message->data();
+    if (playbacke_mode->mode != SPICE_AUDIO_DATA_MODE_RAW &&
+        playbacke_mode->mode != SPICE_AUDIO_DATA_MODE_CELT_0_5_1) {
         THROW("invalid mode");
     }
 
@@ -218,8 +218,8 @@ void PlaybackChannel::handle_mode(RedPeer::InMessage* message)
     }
 
     PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
-    handler->set_handler(RED_PLAYBACK_START, &PlaybackChannel::handle_start,
-                         sizeof(RedPlaybackStart));
+    handler->set_handler(SPICE_MSG_PLAYBACK_START, &PlaybackChannel::handle_start,
+                         sizeof(SpiceMsgPlaybackStart));
 }
 
 void PlaybackChannel::null_handler(RedPeer::InMessage* message)
@@ -230,19 +230,19 @@ void PlaybackChannel::disable()
 {
     PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
 
-    handler->set_handler(RED_PLAYBACK_START, &PlaybackChannel::null_handler, 0);
-    handler->set_handler(RED_PLAYBACK_STOP, &PlaybackChannel::null_handler, 0);
-    handler->set_handler(RED_PLAYBACK_MODE, &PlaybackChannel::null_handler, 0);
-    handler->set_handler(RED_PLAYBACK_DATA, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_START, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_STOP, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_MODE, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_DATA, &PlaybackChannel::null_handler, 0);
 }
 
 void PlaybackChannel::handle_start(RedPeer::InMessage* message)
 {
     PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
-    RedPlaybackStart* start = (RedPlaybackStart*)message->data();
+    SpiceMsgPlaybackStart* start = (SpiceMsgPlaybackStart*)message->data();
 
-    handler->set_handler(RED_PLAYBACK_START, NULL, 0);
-    handler->set_handler(RED_PLAYBACK_STOP, &PlaybackChannel::handle_stop, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_START, NULL, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_STOP, &PlaybackChannel::handle_stop, 0);
 
 #ifdef WAVE_CAPTURE
     start_wave();
@@ -251,7 +251,7 @@ void PlaybackChannel::handle_start(RedPeer::InMessage* message)
         // for now support only one setting
         int celt_mode_err;
 
-        if (start->format != RED_AUDIO_FMT_S16) {
+        if (start->format != SPICE_AUDIO_FMT_S16) {
             THROW("unexpected format");
         }
         int bits_per_sample = 16;
@@ -285,10 +285,10 @@ void PlaybackChannel::handle_stop(RedPeer::InMessage* message)
 {
     PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
 
-    handler->set_handler(RED_PLAYBACK_STOP, NULL, 0);
-    handler->set_handler(RED_PLAYBACK_DATA, NULL, 0);
-    handler->set_handler(RED_PLAYBACK_START, &PlaybackChannel::handle_start,
-                         sizeof(RedPlaybackStart));
+    handler->set_handler(SPICE_MSG_PLAYBACK_STOP, NULL, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_DATA, NULL, 0);
+    handler->set_handler(SPICE_MSG_PLAYBACK_START, &PlaybackChannel::handle_start,
+                         sizeof(SpiceMsgPlaybackStart));
 
 #ifdef WAVE_CAPTURE
     end_wave();
@@ -299,7 +299,7 @@ void PlaybackChannel::handle_stop(RedPeer::InMessage* message)
 
 void PlaybackChannel::handle_raw_data(RedPeer::InMessage* message)
 {
-    RedPlaybackPacket* packet = (RedPlaybackPacket*)message->data();
+    SpiceMsgPlaybackPacket* packet = (SpiceMsgPlaybackPacket*)message->data();
     uint8_t* data = (uint8_t*)(packet + 1);
     uint32_t size = message->size() - sizeof(*packet);
 #ifdef WAVE_CAPTURE
@@ -319,7 +319,7 @@ void PlaybackChannel::handle_raw_data(RedPeer::InMessage* message)
 
 void PlaybackChannel::handle_celt_data(RedPeer::InMessage* message)
 {
-    RedPlaybackPacket* packet = (RedPlaybackPacket*)message->data();
+    SpiceMsgPlaybackPacket* packet = (SpiceMsgPlaybackPacket*)message->data();
     uint8_t* data = (uint8_t*)(packet + 1);
     uint32_t size = message->size() - sizeof(*packet);
     celt_int16_t pcm[256 * 2];
@@ -339,7 +339,7 @@ void PlaybackChannel::handle_celt_data(RedPeer::InMessage* message)
 
 class PlaybackFactory: public ChannelFactory {
 public:
-    PlaybackFactory() : ChannelFactory(RED_CHANNEL_PLAYBACK) {}
+    PlaybackFactory() : ChannelFactory(SPICE_CHANNEL_PLAYBACK) {}
     virtual RedChannel* construct(RedClient& client, uint32_t id)
     {
         return new PlaybackChannel(client, id);
diff --git a/client/record_channel.cpp b/client/record_channel.cpp
index d905ff6e..ccf512c4 100644
--- a/client/record_channel.cpp
+++ b/client/record_channel.cpp
@@ -43,7 +43,7 @@ private:
 
 RecordSamplesMessage::RecordSamplesMessage(RecordChannel& channel)
     : _channel (channel)
-    , _massage (new Message(REDC_RECORD_DATA, sizeof(RedcRecordPacket) + 4096))
+    , _massage (new Message(SPICE_MSGC_RECORD_DATA, sizeof(SpiceMsgcRecordPacket) + 4096))
 {
 }
 
@@ -57,18 +57,18 @@ void RecordSamplesMessage::release()
     _channel.release_message(this);
 }
 
-int RecordChannel::data_mode = RED_AUDIO_DATA_MODE_CELT_0_5_1;
+int RecordChannel::data_mode = SPICE_AUDIO_DATA_MODE_CELT_0_5_1;
 
-class RecordHandler: public MessageHandlerImp<RecordChannel, REDC_RECORD_MESSAGES_END> {
+class RecordHandler: public MessageHandlerImp<RecordChannel, SPICE_MSGC_END_RECORD> {
 public:
     RecordHandler(RecordChannel& channel)
-        : MessageHandlerImp<RecordChannel, REDC_RECORD_MESSAGES_END>(channel) {}
+        : MessageHandlerImp<RecordChannel, SPICE_MSGC_END_RECORD>(channel) {}
 };
 
 RecordChannel::RecordChannel(RedClient& client, uint32_t id)
-    : RedChannel(client, RED_CHANNEL_RECORD, id, new RecordHandler(*this))
+    : RedChannel(client, SPICE_CHANNEL_RECORD, id, new RecordHandler(*this))
     , _wave_recorder (NULL)
-    , _mode (RED_AUDIO_DATA_MODE_INVALD)
+    , _mode (SPICE_AUDIO_DATA_MODE_INVALD)
     , _celt_mode (NULL)
     , _celt_encoder (NULL)
 {
@@ -78,18 +78,18 @@ RecordChannel::RecordChannel(RedClient& client, uint32_t id)
 
     RecordHandler* handler = static_cast<RecordHandler*>(get_message_handler());
 
-    handler->set_handler(RED_MIGRATE, &RecordChannel::handle_migrate, 0);
-    handler->set_handler(RED_SET_ACK, &RecordChannel::handle_set_ack, sizeof(RedSetAck));
-    handler->set_handler(RED_PING, &RecordChannel::handle_ping, sizeof(RedPing));
-    handler->set_handler(RED_WAIT_FOR_CHANNELS, &RecordChannel::handle_wait_for_channels,
-                         sizeof(RedWaitForChannels));
-    handler->set_handler(RED_DISCONNECTING, &RecordChannel::handle_disconnect,
-                         sizeof(RedDisconnect));
-    handler->set_handler(RED_NOTIFY, &RecordChannel::handle_notify, sizeof(RedNotify));
+    handler->set_handler(SPICE_MSG_MIGRATE, &RecordChannel::handle_migrate, 0);
+    handler->set_handler(SPICE_MSG_SET_ACK, &RecordChannel::handle_set_ack, sizeof(SpiceMsgSetAck));
+    handler->set_handler(SPICE_MSG_PING, &RecordChannel::handle_ping, sizeof(SpiceMsgPing));
+    handler->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &RecordChannel::handle_wait_for_channels,
+                         sizeof(SpiceMsgWaitForChannels));
+    handler->set_handler(SPICE_MSG_DISCONNECTING, &RecordChannel::handle_disconnect,
+                         sizeof(SpiceMsgDisconnect));
+    handler->set_handler(SPICE_MSG_NOTIFY, &RecordChannel::handle_notify, sizeof(SpiceMsgNotify));
 
-    handler->set_handler(RED_RECORD_START, &RecordChannel::handle_start, sizeof(RedRecordStart));
+    handler->set_handler(SPICE_MSG_RECORD_START, &RecordChannel::handle_start, sizeof(SpiceMsgRecordStart));
 
-    set_capability(RED_RECORD_CAP_CELT_0_5_1);
+    set_capability(SPICE_RECORD_CAP_CELT_0_5_1);
 }
 
 RecordChannel::~RecordChannel(void)
@@ -117,18 +117,18 @@ bool RecordChannel::abort(void)
 
 void RecordChannel::on_connect()
 {
-    Message* message = new Message(REDC_RECORD_MODE, sizeof(RedcRecordMode));
-    RedcRecordMode *mode = (RedcRecordMode *)message->data();
+    Message* message = new Message(SPICE_MSGC_RECORD_MODE, sizeof(SpiceMsgcRecordMode));
+    SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)message->data();
     mode->time = get_mm_time();
-    mode->mode = _mode = test_capability(RED_RECORD_CAP_CELT_0_5_1) ? RecordChannel::data_mode :
-                                                                      RED_AUDIO_DATA_MODE_RAW;
+    mode->mode = _mode = test_capability(SPICE_RECORD_CAP_CELT_0_5_1) ? RecordChannel::data_mode :
+                                                                      SPICE_AUDIO_DATA_MODE_RAW;
     post_message(message);
 }
 
 void RecordChannel::send_start_mark()
 {
-    Message* message = new Message(REDC_RECORD_START_MARK, sizeof(RedcRecordStartMark));
-    RedcRecordStartMark *start_mark = (RedcRecordStartMark *)message->data();
+    Message* message = new Message(SPICE_MSGC_RECORD_START_MARK, sizeof(SpiceMsgcRecordStartMark));
+    SpiceMsgcRecordStartMark *start_mark = (SpiceMsgcRecordStartMark *)message->data();
     start_mark->time = get_mm_time();
     post_message(message);
 }
@@ -136,14 +136,14 @@ void RecordChannel::send_start_mark()
 void RecordChannel::handle_start(RedPeer::InMessage* message)
 {
     RecordHandler* handler = static_cast<RecordHandler*>(get_message_handler());
-    RedRecordStart* start = (RedRecordStart*)message->data();
+    SpiceMsgRecordStart* start = (SpiceMsgRecordStart*)message->data();
 
-    handler->set_handler(RED_RECORD_START, NULL, 0);
-    handler->set_handler(RED_RECORD_STOP, &RecordChannel::handle_stop, 0);
+    handler->set_handler(SPICE_MSG_RECORD_START, NULL, 0);
+    handler->set_handler(SPICE_MSG_RECORD_STOP, &RecordChannel::handle_stop, 0);
     ASSERT(!_wave_recorder && !_celt_mode && !_celt_encoder);
 
     // for now support only one setting
-    if (start->format != RED_AUDIO_FMT_S16) {
+    if (start->format != SPICE_AUDIO_FMT_S16) {
         THROW("unexpected format");
     }
 
@@ -176,8 +176,8 @@ void RecordChannel::handle_start(RedPeer::InMessage* message)
 void RecordChannel::handle_stop(RedPeer::InMessage* message)
 {
     RecordHandler* handler = static_cast<RecordHandler*>(get_message_handler());
-    handler->set_handler(RED_RECORD_START, &RecordChannel::handle_start, sizeof(RedRecordStart));
-    handler->set_handler(RED_RECORD_STOP, NULL, 0);
+    handler->set_handler(SPICE_MSG_RECORD_START, &RecordChannel::handle_start, sizeof(SpiceMsgRecordStart));
+    handler->set_handler(SPICE_MSG_RECORD_STOP, NULL, 0);
     if (!_wave_recorder) {
         return;
     }
@@ -244,7 +244,7 @@ void RecordChannel::push_frame(uint8_t *frame)
     uint8_t celt_buf[CELT_COMPRESSED_FRAME_BYTES];
     int n;
 
-    if (_mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+    if (_mode == SPICE_AUDIO_DATA_MODE_CELT_0_5_1) {
         n = celt051_encode(_celt_encoder, (celt_int16_t *)frame, NULL, celt_buf,
                            CELT_COMPRESSED_FRAME_BYTES);
         if (n < 0) {
@@ -255,8 +255,8 @@ void RecordChannel::push_frame(uint8_t *frame)
         n = _frame_bytes;
     }
     RedPeer::OutMessage& peer_message = message->peer_message();
-    peer_message.resize(n + sizeof(RedcRecordPacket));
-    RedcRecordPacket* packet = (RedcRecordPacket*)peer_message.data();
+    peer_message.resize(n + sizeof(SpiceMsgcRecordPacket));
+    SpiceMsgcRecordPacket* packet = (SpiceMsgcRecordPacket*)peer_message.data();
     packet->time = get_mm_time();
     memcpy(packet->data, frame, n);
     post_message(message);
@@ -264,7 +264,7 @@ void RecordChannel::push_frame(uint8_t *frame)
 
 class RecordFactory: public ChannelFactory {
 public:
-    RecordFactory() : ChannelFactory(RED_CHANNEL_RECORD) {}
+    RecordFactory() : ChannelFactory(SPICE_CHANNEL_RECORD) {}
     virtual RedChannel* construct(RedClient& client, uint32_t id)
     {
         return new RecordChannel(client, id);
diff --git a/client/red_cairo_canvas.cpp b/client/red_cairo_canvas.cpp
index d565e493..08880ea9 100644
--- a/client/red_cairo_canvas.cpp
+++ b/client/red_cairo_canvas.cpp
@@ -69,7 +69,7 @@ void CCanvas::create_pixmap(int width, int height, RedWindow *win)
 void CCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
 {
     for (int i = 0; i < (int)region.num_rects; i++) {
-        Rect* r = &region.rects[i];
+        SpiceRect* r = &region.rects[i];
         dest_dc.copy_pixels(*_pixmap, r->left, r->top, *r);
     }
 }
@@ -113,80 +113,80 @@ void CCanvas::set_access_params(unsigned long base, unsigned long max)
     canvas_set_access_params(_canvas, base, max);
 }
 
-void CCanvas::draw_fill(Rect *bbox, Clip *clip, Fill *fill)
+void CCanvas::draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
 {
     canvas_draw_fill(_canvas, bbox, clip, fill);
 }
 
-void CCanvas::draw_text(Rect *bbox, Clip *clip, Text *text)
+void CCanvas::draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
 {
     canvas_draw_text(_canvas, bbox, clip, text);
 }
 
-void CCanvas::draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque)
+void CCanvas::draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
 {
     canvas_draw_opaque(_canvas, bbox, clip, opaque);
 }
 
-void CCanvas::draw_copy(Rect *bbox, Clip *clip, Copy *copy)
+void CCanvas::draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
 {
     canvas_draw_copy(_canvas, bbox, clip, copy);
 }
 
-void CCanvas::draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent)
+void CCanvas::draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
 {
     canvas_draw_transparent(_canvas, bbox, clip, transparent);
 }
 
-void CCanvas::draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+void CCanvas::draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
 {
     canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
 }
 
-void CCanvas::copy_bits(Rect *bbox, Clip *clip, Point *src_pos)
+void CCanvas::copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     canvas_copy_bits(_canvas, bbox, clip, src_pos);
 }
 
-void CCanvas::draw_blend(Rect *bbox, Clip *clip, Blend *blend)
+void CCanvas::draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
 {
     canvas_draw_blend(_canvas, bbox, clip, blend);
 }
 
-void CCanvas::draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness)
+void CCanvas::draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
 {
     canvas_draw_blackness(_canvas, bbox, clip, blackness);
 }
 
-void CCanvas::draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness)
+void CCanvas::draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
 {
     canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
 }
 
-void CCanvas::draw_invers(Rect *bbox, Clip *clip, Invers *invers)
+void CCanvas::draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
 {
     canvas_draw_invers(_canvas, bbox, clip, invers);
 }
 
-void CCanvas::draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3)
+void CCanvas::draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
 {
     canvas_draw_rop3(_canvas, bbox, clip, rop3);
 }
 
-void CCanvas::draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke)
+void CCanvas::draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
 {
     canvas_draw_stroke(_canvas, bbox, clip, stroke);
 }
 
 #ifdef WIN32
-void CCanvas::put_image(HDC dc, const PixmapHeader& image, const Rect& dest, const QRegion* clip)
+void CCanvas::put_image(HDC dc, const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
 {
     canvas_put_image(_canvas, dc, &dest, image.data, image.width, image.height, image.stride,
                      clip);
 }
 
 #else
-void CCanvas::put_image(const PixmapHeader& image, const Rect& dest, const QRegion* clip)
+void CCanvas::put_image(const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
 {
     canvas_put_image(_canvas, &dest, image.data, image.width, image.height, image.stride,
                      clip);
diff --git a/client/red_cairo_canvas.h b/client/red_cairo_canvas.h
index 43ee78a5..2bcb3a89 100644
--- a/client/red_cairo_canvas.h
+++ b/client/red_cairo_canvas.h
@@ -37,9 +37,9 @@ public:
     virtual void copy_pixels(const QRegion& region, RedDrawable& dc);
 #ifdef WIN32
     virtual void put_image(HDC dc, const PixmapHeader& image,
-                           const Rect& dest, const QRegion* clip);
+                           const SpiceRect& dest, const QRegion* clip);
 #else
-    virtual void put_image(const PixmapHeader& image, const Rect& dest,
+    virtual void put_image(const PixmapHeader& image, const SpiceRect& dest,
                            const QRegion* clip);
 #endif
 
@@ -47,19 +47,19 @@ public:
 
 protected:
     virtual void set_access_params(unsigned long base, unsigned long max);
-    virtual void draw_fill(Rect *bbox, Clip *clip, Fill *fill);
-    virtual void draw_copy(Rect *bbox, Clip *clip, Copy *copy);
-    virtual void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque);
-    virtual void copy_bits(Rect *bbox, Clip *clip, Point *src_pos);
-    virtual void draw_text(Rect *bbox, Clip *clip, Text *text);
-    virtual void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke);
-    virtual void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3);
-    virtual void draw_blend(Rect *bbox, Clip *clip, Blend *blend);
-    virtual void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness);
-    virtual void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness);
-    virtual void draw_invers(Rect *bbox, Clip *clip, Invers *invers);
-    virtual void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent);
-    virtual void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+    virtual void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+    virtual void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+    virtual void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+    virtual void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+    virtual void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
+    virtual void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+    virtual void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+    virtual void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+    virtual void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+    virtual void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+    virtual void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+    virtual void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
+    virtual void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
 
 private:
     void create_pixmap(int width, int height, RedWindow *win);
diff --git a/client/red_channel.cpp b/client/red_channel.cpp
index 25e4e04d..e360d5f4 100644
--- a/client/red_channel.cpp
+++ b/client/red_channel.cpp
@@ -43,9 +43,9 @@ RedChannelBase::~RedChannelBase()
 
 void RedChannelBase::link(uint32_t connection_id, const std::string& password)
 {
-    RedLinkHeader header;
-    RedLinkMess link_mess;
-    RedLinkReply* reply;
+    SpiceLinkHeader header;
+    SpiceLinkMess link_mess;
+    SpiceLinkReply* reply;
     uint32_t link_res;
     uint32_t i;
 
@@ -54,10 +54,10 @@ void RedChannelBase::link(uint32_t connection_id, const std::string& password)
     BIO *bioKey;
     RSA *rsa;
 
-    header.magic = RED_MAGIC;
+    header.magic = SPICE_MAGIC;
     header.size = sizeof(link_mess);
-    header.major_version = RED_VERSION_MAJOR;
-    header.minor_version = RED_VERSION_MINOR;
+    header.major_version = SPICE_VERSION_MAJOR;
+    header.minor_version = SPICE_VERSION_MINOR;
     link_mess.connection_id = connection_id;
     link_mess.channel_type = _type;
     link_mess.channel_id = _id;
@@ -78,14 +78,14 @@ void RedChannelBase::link(uint32_t connection_id, const std::string& password)
 
     recive((uint8_t*)&header, sizeof(header));
 
-    if (header.magic != RED_MAGIC) {
+    if (header.magic != SPICE_MAGIC) {
         THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "bad magic");
     }
 
-    if (header.major_version != RED_VERSION_MAJOR) {
+    if (header.major_version != SPICE_VERSION_MAJOR) {
         THROW_ERR(SPICEC_ERROR_CODE_VERSION_MISMATCH,
                   "version mismatch: expect %u got %u",
-                  RED_VERSION_MAJOR,
+                  SPICE_VERSION_MAJOR,
                   header.major_version);
     }
 
@@ -94,9 +94,9 @@ void RedChannelBase::link(uint32_t connection_id, const std::string& password)
     AutoArray<uint8_t> reply_buf(new uint8_t[header.size]);
     recive(reply_buf.get(), header.size);
 
-    reply = (RedLinkReply *)reply_buf.get();
+    reply = (SpiceLinkReply *)reply_buf.get();
 
-    if (reply->error != RED_ERR_OK) {
+    if (reply->error != SPICE_LINK_ERR_OK) {
         THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "connect error %u", reply->error);
     }
 
@@ -123,7 +123,7 @@ void RedChannelBase::link(uint32_t connection_id, const std::string& password)
 
     bioKey = BIO_new(BIO_s_mem());
     if (bioKey != NULL) {
-        BIO_write(bioKey, reply->pub_key, RED_TICKET_PUBKEY_BYTES);
+        BIO_write(bioKey, reply->pub_key, SPICE_TICKET_PUBKEY_BYTES);
         pubkey = d2i_PUBKEY_bio(bioKey, NULL);
         rsa = pubkey->pkey.rsa;
         nRSASize = RSA_size(rsa);
@@ -149,8 +149,8 @@ void RedChannelBase::link(uint32_t connection_id, const std::string& password)
     BIO_free(bioKey);
 
     recive((uint8_t*)&link_res, sizeof(link_res));
-    if (link_res != RED_ERR_OK) {
-        int error_code = (link_res == RED_ERR_PERMISSION_DENIED) ?
+    if (link_res != SPICE_LINK_ERR_OK) {
+        int error_code = (link_res == SPICE_LINK_ERR_PERMISSION_DENIED) ?
                                 SPICEC_ERROR_CODE_CONNECT_FAILED : SPICEC_ERROR_CODE_CONNECT_FAILED;
         THROW_ERR(error_code, "connect failed %u", link_res);
     }
@@ -253,7 +253,7 @@ RedChannel::RedChannel(RedClient& client, uint8_t type, uint8_t id,
     , _loop (this)
     , _send_trigger (*this)
     , _disconnect_stamp (0)
-    , _disconnect_reason (RED_ERR_OK)
+    , _disconnect_reason (SPICE_LINK_ERR_OK)
 {
     _loop.add_trigger(_send_trigger);
     _loop.add_trigger(_abort_trigger);
@@ -506,7 +506,7 @@ void RedChannel::on_send_trigger()
 void RedChannel::on_message_recived()
 {
     if (_message_ack_count && !--_message_ack_count) {
-        post_message(new Message(REDC_ACK, 0));
+        post_message(new Message(SPICE_MSGC_ACK, 0));
         _message_ack_count = _message_ack_window;
     }
 }
@@ -521,8 +521,8 @@ void RedChannel::on_message_complition(uint64_t serial)
 void RedChannel::recive_messages()
 {
     for (;;) {
-        uint32_t n = RedPeer::recive((uint8_t*)&_incomming_header, sizeof(RedDataHeader));
-        if (n != sizeof(RedDataHeader)) {
+        uint32_t n = RedPeer::recive((uint8_t*)&_incomming_header, sizeof(SpiceDataHeader));
+        if (n != sizeof(SpiceDataHeader)) {
             _incomming_header_pos = n;
             return;
         }
@@ -558,8 +558,8 @@ void RedChannel::on_event()
     if (_incomming_header_pos) {
         _incomming_header_pos += RedPeer::recive(((uint8_t*)&_incomming_header) +
                                                  _incomming_header_pos,
-                                                 sizeof(RedDataHeader) - _incomming_header_pos);
-        if (_incomming_header_pos != sizeof(RedDataHeader)) {
+                                                 sizeof(SpiceDataHeader) - _incomming_header_pos);
+        if (_incomming_header_pos != sizeof(SpiceDataHeader)) {
             return;
         }
         _incomming_header_pos = 0;
@@ -604,7 +604,7 @@ void RedChannel::send_migrate_flush_mark()
         send(message.get()->peer_message());
     }
     lock.unlock();
-    std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(REDC_MIGRATE_FLUSH_MARK, 0));
+    std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(SPICE_MSGC_MIGRATE_FLUSH_MARK, 0));
     send(*message);
 }
 
@@ -613,20 +613,20 @@ void RedChannel::handle_migrate(RedPeer::InMessage* message)
     DBG(0, "channel type %u id %u", get_type(), get_id());
     _socket_in_loop = false;
     _loop.remove_socket(*this);
-    RedMigrate* migrate = (RedMigrate*)message->data();
-    if (migrate->flags & RED_MIGRATE_NEED_FLUSH) {
+    SpiceMsgMigrate* migrate = (SpiceMsgMigrate*)message->data();
+    if (migrate->flags & SPICE_MIGRATE_NEED_FLUSH) {
         send_migrate_flush_mark();
     }
     AutoRef<CompundInMessage> data_message;
-    if (migrate->flags & RED_MIGRATE_NEED_DATA_TRANSFER) {
+    if (migrate->flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) {
         data_message.reset(recive());
     }
     _client.migrate_channel(*this);
-    if (migrate->flags & RED_MIGRATE_NEED_DATA_TRANSFER) {
-        if ((*data_message)->type() != RED_MIGRATE_DATA) {
-            THROW("expect RED_MIGRATE_DATA");
+    if (migrate->flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) {
+        if ((*data_message)->type() != SPICE_MSG_MIGRATE_DATA) {
+            THROW("expect SPICE_MSG_MIGRATE_DATA");
         }
-        std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(REDC_MIGRATE_DATA,
+        std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(SPICE_MSGC_MIGRATE_DATA,
                                                                           (*data_message)->size()));
         memcpy(message->data(), (*data_message)->data(), (*data_message)->size());
         send(*message);
@@ -640,31 +640,31 @@ void RedChannel::handle_migrate(RedPeer::InMessage* message)
 
 void RedChannel::handle_set_ack(RedPeer::InMessage* message)
 {
-    RedSetAck* ack = (RedSetAck*)message->data();
+    SpiceMsgSetAck* ack = (SpiceMsgSetAck*)message->data();
     _message_ack_window = _message_ack_count = ack->window;
-    Message *responce = new Message(REDC_ACK_SYNC, sizeof(uint32_t));
+    Message *responce = new Message(SPICE_MSGC_ACK_SYNC, sizeof(uint32_t));
     *(uint32_t *)responce->data() = ack->generation;
     post_message(responce);
 }
 
 void RedChannel::handle_ping(RedPeer::InMessage* message)
 {
-    RedPing *ping = (RedPing *)message->data();
-    Message *pong = new Message(REDC_PONG, sizeof(RedPing));
-    *(RedPing *)pong->data() = *ping;
+    SpiceMsgPing *ping = (SpiceMsgPing *)message->data();
+    Message *pong = new Message(SPICE_MSGC_PONG, sizeof(SpiceMsgPing));
+    *(SpiceMsgPing *)pong->data() = *ping;
     post_message(pong);
 }
 
 void RedChannel::handle_disconnect(RedPeer::InMessage* message)
 {
-    RedDisconnect *disconnect = (RedDisconnect *)message->data();
+    SpiceMsgDisconnect *disconnect = (SpiceMsgDisconnect *)message->data();
     _disconnect_stamp = disconnect->time_stamp;
     _disconnect_reason = disconnect->reason;
 }
 
 void RedChannel::handle_notify(RedPeer::InMessage* message)
 {
-    RedNotify *notify = (RedNotify *)message->data();
+    SpiceMsgNotify *notify = (SpiceMsgNotify *)message->data();
     const char *sevirity;
     const char *visibility;
     const char *message_str = "";
@@ -674,12 +674,12 @@ void RedChannel::handle_notify(RedPeer::InMessage* message)
     static const char* visibility_strings[] = {"!", "!!", "!!!"};
 
 
-    if (notify->severty > RED_NOTIFY_SEVERITY_ERROR) {
+    if (notify->severty > SPICE_NOTIFY_SEVERITY_ERROR) {
         THROW("bad sevirity");
     }
     sevirity = sevirity_strings[notify->severty];
 
-    if (notify->visibilty > RED_NOTIFY_VISIBILITY_HIGH) {
+    if (notify->visibilty > SPICE_NOTIFY_VISIBILITY_HIGH) {
         THROW("bad visibilty");
     }
     visibility = visibility_strings[notify->visibilty];
@@ -706,7 +706,7 @@ void RedChannel::handle_notify(RedPeer::InMessage* message)
 
 void RedChannel::handle_wait_for_channels(RedPeer::InMessage* message)
 {
-    RedWaitForChannels *wait = (RedWaitForChannels *)message->data();
+    SpiceMsgWaitForChannels *wait = (SpiceMsgWaitForChannels *)message->data();
     if (message->size() < sizeof(*wait) + wait->wait_count * sizeof(wait->wait_list[0])) {
         THROW("access violation");
     }
diff --git a/client/red_channel.h b/client/red_channel.h
index 996aaf66..c20eac36 100644
--- a/client/red_channel.h
+++ b/client/red_channel.h
@@ -181,7 +181,7 @@ private:
     RedChannel::OutMessage* _outgoing_message;
     uint32_t _outgoing_pos;
 
-    RedDataHeader _incomming_header;
+    SpiceDataHeader _incomming_header;
     uint32_t _incomming_header_pos;
     RedPeer::CompundInMessage* _incomming_message;
     uint32_t _incomming_message_pos;
@@ -270,10 +270,10 @@ void MessageHandlerImp<HandlerClass, end_message>::handle_message(RedPeer::Compu
               _handlers[message.type()].mess_size);
     }
     if (message.sub_list()) {
-        RedSubMessageList *sub_list;
-        sub_list = (RedSubMessageList *)(message.data() + message.sub_list());
+        SpiceSubMessageList *sub_list;
+        sub_list = (SpiceSubMessageList *)(message.data() + message.sub_list());
         for (int i = 0; i < sub_list->size; i++) {
-            RedSubMessage *sub = (RedSubMessage *)(message.data() + sub_list->sub_messages[i]);
+            SpicedSubMessage *sub = (SpicedSubMessage *)(message.data() + sub_list->sub_messages[i]);
             //todo: test size
             RedPeer::InMessage sub_message(sub->type, sub->size, (uint8_t *)(sub + 1));
             (_obj.*_handlers[sub_message.type()].handler)(&sub_message);
diff --git a/client/red_client.cpp b/client/red_client.cpp
index 57ec3502..40c77677 100644
--- a/client/red_client.cpp
+++ b/client/red_client.cpp
@@ -49,7 +49,7 @@ public:
 
         virtual bool operator() (RedChannel& channel)
         {
-            if (channel.get_type() == RED_CHANNEL_DISPLAY) {
+            if (channel.get_type() == SPICE_CHANNEL_DISPLAY) {
                 static_cast<DisplayChannel&>(channel).set_capture_mode(_capture_mode);
             }
             return true;
@@ -61,7 +61,7 @@ public:
 
     virtual void response(AbstractProcessLoop& events_loop)
     {
-        bool capture_mode = _client.get_mouse_mode() == RED_MOUSE_MODE_SERVER;
+        bool capture_mode = _client.get_mouse_mode() == SPICE_MOUSE_MODE_SERVER;
         if (!capture_mode) {
             _client.get_application().release_mouse_capture();
         }
@@ -169,7 +169,7 @@ void Migrate::run()
 
     DBG(0, "");
     try {
-        conn_type = _client.get_connection_options(RED_CHANNEL_MAIN);
+        conn_type = _client.get_connection_options(SPICE_CHANNEL_MAIN);
         RedPeer::ConnectionOptions con_opt(conn_type, _port, _sport, _auth_options);
         MigChannels::iterator iter = _channels.begin();
         connection_id = _client.get_connection_id();
@@ -189,10 +189,10 @@ void Migrate::run()
     Lock lock(_lock);
     _cond.notify_one();
     if (_connected) {
-        Message* message = new Message(REDC_MIGRATE_CONNECTED, 0);
+        Message* message = new Message(SPICE_MSGC_MAIN_MIGRATE_CONNECTED, 0);
         _client.post_message(message);
     } else {
-        Message* message = new Message(REDC_MIGRATE_CONNECT_ERROR, 0);
+        Message* message = new Message(SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR, 0);
         _client.post_message(message);
     }
     _running = false;
@@ -205,13 +205,13 @@ void* Migrate::worker_main(void *data)
     return NULL;
 }
 
-void Migrate::start(const RedMigrationBegin* migrate)
+void Migrate::start(const SpiceMsgMainMigrationBegin* migrate)
 {
     DBG(0, "");
     abort();
-    if ((RED_VERSION_MAJOR == 1) && (_client.get_peer_minor() < 2)) {
+    if ((SPICE_VERSION_MAJOR == 1) && (_client.get_peer_minor() < 2)) {
         LOG_INFO("server minor version incompatible for destination authentication"
-                 "(missing dest pubkey in RedMigrationBegin)");
+                 "(missing dest pubkey in SpiceMsgMainMigrationBegin)");
         OldRedMigrationBegin* old_migrate = (OldRedMigrationBegin*)migrate;
         _host.assign(old_migrate->host);
         _port = old_migrate->port ? old_migrate->port : -1;
@@ -291,18 +291,18 @@ void AgentTimer::response(AbstractProcessLoop& events_loop)
     THROW_ERR(SPICEC_ERROR_CODE_AGENT_TIMEOUT, "vdagent timeout");
 }
 
-class MainChannelLoop: public MessageHandlerImp<RedClient, RED_MESSAGES_END> {
+class MainChannelLoop: public MessageHandlerImp<RedClient, SPICE_MSG_END_MAIN> {
 public:
-    MainChannelLoop(RedClient& client): MessageHandlerImp<RedClient, RED_MESSAGES_END>(client) {}
+    MainChannelLoop(RedClient& client): MessageHandlerImp<RedClient, SPICE_MSG_END_MAIN>(client) {}
 };
 
 RedClient::RedClient(Application& application)
-    : RedChannel(*this, RED_CHANNEL_MAIN, 0, new MainChannelLoop(*this))
+    : RedChannel(*this, SPICE_CHANNEL_MAIN, 0, new MainChannelLoop(*this))
     , _application (application)
     , _port (-1)
     , _sport (-1)
     , _connection_id (0)
-    , _mouse_mode (RED_MOUSE_MODE_SERVER)
+    , _mouse_mode (SPICE_MOUSE_MODE_SERVER)
     , _notify_disconnect (false)
     , _auto_display_res (false)
     , _aborting (false)
@@ -318,32 +318,32 @@ RedClient::RedClient(Application& application)
 {
     MainChannelLoop* message_loop = static_cast<MainChannelLoop*>(get_message_handler());
 
-    message_loop->set_handler(RED_MIGRATE, &RedClient::handle_migrate, 0);
-    message_loop->set_handler(RED_SET_ACK, &RedClient::handle_set_ack, sizeof(RedSetAck));
-    message_loop->set_handler(RED_PING, &RedClient::handle_ping, sizeof(RedPing));
-    message_loop->set_handler(RED_WAIT_FOR_CHANNELS, &RedClient::handle_wait_for_channels,
-                              sizeof(RedWaitForChannels));
-    message_loop->set_handler(RED_DISCONNECTING, &RedClient::handle_disconnect,
-                              sizeof(RedDisconnect));
-    message_loop->set_handler(RED_NOTIFY, &RedClient::handle_notify, sizeof(RedNotify));
-
-    message_loop->set_handler(RED_MIGRATE_BEGIN, &RedClient::handle_migrate_begin,
-                              sizeof(RedMigrationBegin));
-    message_loop->set_handler(RED_MIGRATE_CANCEL, &RedClient::handle_migrate_cancel, 0);
-    message_loop->set_handler(RED_INIT, &RedClient::handle_init, sizeof(RedInit));
-    message_loop->set_handler(RED_CHANNELS_LIST, &RedClient::handle_channels,
-                              sizeof(RedChannels));
-    message_loop->set_handler(RED_MOUSE_MODE, &RedClient::handle_mouse_mode,
-                              sizeof(RedMouseMode));
-    message_loop->set_handler(RED_MULTI_MEDIA_TIME, &RedClient::handle_mm_time,
-                              sizeof(RedMultiMediaTime));
-
-    message_loop->set_handler(RED_AGENT_CONNECTED, &RedClient::handle_agent_connected, 0);
-    message_loop->set_handler(RED_AGENT_DISCONNECTED, &RedClient::handle_agent_disconnected,
-                              sizeof(RedAgentDisconnect));
-    message_loop->set_handler(RED_AGENT_DATA, &RedClient::handle_agent_data, 0);
-    message_loop->set_handler(RED_AGENT_TOKEN, &RedClient::handle_agent_tokens,
-                              sizeof(RedAgentTokens));
+    message_loop->set_handler(SPICE_MSG_MIGRATE, &RedClient::handle_migrate, 0);
+    message_loop->set_handler(SPICE_MSG_SET_ACK, &RedClient::handle_set_ack, sizeof(SpiceMsgSetAck));
+    message_loop->set_handler(SPICE_MSG_PING, &RedClient::handle_ping, sizeof(SpiceMsgPing));
+    message_loop->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &RedClient::handle_wait_for_channels,
+                              sizeof(SpiceMsgWaitForChannels));
+    message_loop->set_handler(SPICE_MSG_DISCONNECTING, &RedClient::handle_disconnect,
+                              sizeof(SpiceMsgDisconnect));
+    message_loop->set_handler(SPICE_MSG_NOTIFY, &RedClient::handle_notify, sizeof(SpiceMsgNotify));
+
+    message_loop->set_handler(SPICE_MSG_MAIN_MIGRATE_BEGIN, &RedClient::handle_migrate_begin,
+                              sizeof(SpiceMsgMainMigrationBegin));
+    message_loop->set_handler(SPICE_MSG_MAIN_MIGRATE_CANCEL, &RedClient::handle_migrate_cancel, 0);
+    message_loop->set_handler(SPICE_MSG_MAIN_INIT, &RedClient::handle_init, sizeof(SpiceMsgMainInit));
+    message_loop->set_handler(SPICE_MSG_MAIN_CHANNELS_LIST, &RedClient::handle_channels,
+                              sizeof(SpiceMsgChannels));
+    message_loop->set_handler(SPICE_MSG_MAIN_MOUSE_MODE, &RedClient::handle_mouse_mode,
+                              sizeof(SpiceMsgMainMouseMode));
+    message_loop->set_handler(SPICE_MSG_MAIN_MULTI_MEDIA_TIME, &RedClient::handle_mm_time,
+                              sizeof(SpiceMsgMainMultiMediaTime));
+
+    message_loop->set_handler(SPICE_MSG_MAIN_AGENT_CONNECTED, &RedClient::handle_agent_connected, 0);
+    message_loop->set_handler(SPICE_MSG_MAIN_AGENT_DISCONNECTED, &RedClient::handle_agent_disconnected,
+                              sizeof(SpiceMsgMainAgentDisconnect));
+    message_loop->set_handler(SPICE_MSG_MAIN_AGENT_DATA, &RedClient::handle_agent_data, 0);
+    message_loop->set_handler(SPICE_MSG_MAIN_AGENT_TOKEN, &RedClient::handle_agent_tokens,
+                              sizeof(SpiceMsgMainAgentTokens));
     start();
 }
 
@@ -385,7 +385,7 @@ void RedClient::on_connect()
 {
     AutoRef<ConnectedEvent> event(new ConnectedEvent());
     push_event(*event);
-    _migrate.add_channel(new MigChannel(RED_CHANNEL_MAIN, 0, get_common_caps(),
+    _migrate.add_channel(new MigChannel(SPICE_CHANNEL_MAIN, 0, get_common_caps(),
                                         get_caps()));
 }
 
@@ -525,7 +525,7 @@ bool RedClient::abort()
 void RedClient::handle_migrate_begin(RedPeer::InMessage* message)
 {
     DBG(0, "");
-    RedMigrationBegin* migrate = (RedMigrationBegin*)message->data();
+    SpiceMsgMainMigrationBegin* migrate = (SpiceMsgMainMigrationBegin*)message->data();
     //add mig channels
     _migrate.start(migrate);
 }
@@ -588,7 +588,7 @@ void RedClient::send_agent_monitors_config()
         }
     }
 
-    Message* message = new Message(REDC_AGENT_DATA,sizeof(VDAgentMessage) +
+    Message* message = new Message(SPICE_MSGC_MAIN_AGENT_DATA,sizeof(VDAgentMessage) +
                                    sizeof(VDAgentMonitorsConfig) +
                                    monitors.size() * sizeof(VDAgentMonConfig));
     VDAgentMessage* msg = (VDAgentMessage*)message->data();
@@ -668,7 +668,7 @@ void RedClient::on_display_mode_change()
     Lock lock(_channels_lock);
     Channels::iterator iter = _channels.begin();
     for (; iter != _channels.end(); ++iter) {
-        if ((*iter)->get_type() == RED_CHANNEL_DISPLAY) {
+        if ((*iter)->get_type() == SPICE_CHANNEL_DISPLAY) {
             ((DisplayChannel *)(*iter))->recreate_ogl_context();
         }
     }
@@ -682,7 +682,7 @@ void RedClient::set_mouse_mode(uint32_t supported_modes, uint32_t current_mode)
         Lock lock(_channels_lock);
         Channels::iterator iter = _channels.begin();
         for (; iter != _channels.end(); ++iter) {
-            if ((*iter)->get_type() == RED_CHANNEL_CURSOR) {
+            if ((*iter)->get_type() == SPICE_CHANNEL_CURSOR) {
                 ((CursorChannel *)(*iter))->on_mouse_mode_change();
             }
         }
@@ -690,17 +690,17 @@ void RedClient::set_mouse_mode(uint32_t supported_modes, uint32_t current_mode)
         push_event(*event);
     }
     // FIXME: use configured mouse mode (currently, use client mouse mode if supported by server)
-    if ((supported_modes & RED_MOUSE_MODE_CLIENT) && (current_mode != RED_MOUSE_MODE_CLIENT)) {
-        Message* message = new Message(REDC_MOUSE_MODE_REQUEST, sizeof(RedcMouseModeRequest));
-        RedcMouseModeRequest* mouse_mode_request = (RedcMouseModeRequest*)message->data();
-        mouse_mode_request->mode = RED_MOUSE_MODE_CLIENT;
+    if ((supported_modes & SPICE_MOUSE_MODE_CLIENT) && (current_mode != SPICE_MOUSE_MODE_CLIENT)) {
+        Message* message = new Message(SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST, sizeof(SpiceMsgcMainMouseModeRequest));
+        SpiceMsgcMainMouseModeRequest* mouse_mode_request = (SpiceMsgcMainMouseModeRequest*)message->data();
+        mouse_mode_request->mode = SPICE_MOUSE_MODE_CLIENT;
         post_message(message);
     }
 }
 
 void RedClient::handle_init(RedPeer::InMessage* message)
 {
-    RedInit *init = (RedInit *)message->data();
+    SpiceMsgMainInit *init = (SpiceMsgMainInit *)message->data();
     _connection_id = init->session_id;
     set_mm_time(init->multi_media_time);
     calc_pixmap_cach_and_glz_window_size(init->display_channels_hint, init->ram_hint);
@@ -709,8 +709,8 @@ void RedClient::handle_init(RedPeer::InMessage* message)
     _agent_tokens = init->agent_tokens;
     _agent_connected = !!init->agent_connected;
     if (_agent_connected) {
-        Message* msg = new Message(REDC_AGENT_START, sizeof(RedcAgentStart));
-        RedcAgentStart* agent_start = (RedcAgentStart *)msg->data();
+        Message* msg = new Message(SPICE_MSGC_MAIN_AGENT_START, sizeof(SpiceMsgcMainAgentStart));
+        SpiceMsgcMainAgentStart* agent_start = (SpiceMsgcMainAgentStart *)msg->data();
         agent_start->num_tokens = ~0;
         post_message(msg);
     }
@@ -720,14 +720,14 @@ void RedClient::handle_init(RedPeer::InMessage* message)
             send_agent_monitors_config();
         }
     } else {
-        post_message(new Message(REDC_ATTACH_CHANNELS, 0));
+        post_message(new Message(SPICE_MSGC_MAIN_ATTACH_CHANNELS, 0));
     }
 }
 
 void RedClient::handle_channels(RedPeer::InMessage* message)
 {
-    RedChannels *init = (RedChannels *)message->data();
-    RedChannelInit* channels = init->channels;
+    SpiceMsgChannels *init = (SpiceMsgChannels *)message->data();
+    SpiceChannelId* channels = init->channels;
     for (unsigned int i = 0; i < init->num_of_channels; i++) {
         create_channel(channels[i].type, channels[i].id);
     }
@@ -735,13 +735,13 @@ void RedClient::handle_channels(RedPeer::InMessage* message)
 
 void RedClient::handle_mouse_mode(RedPeer::InMessage* message)
 {
-    RedMouseMode *mouse_mode = (RedMouseMode *)message->data();
+    SpiceMsgMainMouseMode *mouse_mode = (SpiceMsgMainMouseMode *)message->data();
     set_mouse_mode(mouse_mode->supported_modes, mouse_mode->current_mode);
 }
 
 void RedClient::handle_mm_time(RedPeer::InMessage* message)
 {
-    RedMultiMediaTime *mm_time = (RedMultiMediaTime *)message->data();
+    SpiceMsgMainMultiMediaTime *mm_time = (SpiceMsgMainMultiMediaTime *)message->data();
     set_mm_time(mm_time->time);
 }
 
@@ -749,8 +749,8 @@ void RedClient::handle_agent_connected(RedPeer::InMessage* message)
 {
     DBG(0, "");
     _agent_connected = true;
-    Message* msg = new Message(REDC_AGENT_START, sizeof(RedcAgentStart));
-    RedcAgentStart* agent_start = (RedcAgentStart *)msg->data();
+    Message* msg = new Message(SPICE_MSGC_MAIN_AGENT_START, sizeof(SpiceMsgcMainAgentStart));
+    SpiceMsgcMainAgentStart* agent_start = (SpiceMsgcMainAgentStart *)msg->data();
     agent_start->num_tokens = ~0;
     post_message(msg);
     if (_auto_display_res && !_agent_mon_config_sent) {
@@ -776,7 +776,7 @@ void RedClient::on_agent_reply(VDAgentReply* reply)
     }
     switch (reply->type) {
     case VD_AGENT_MONITORS_CONFIG:
-        post_message(new Message(REDC_ATTACH_CHANNELS, 0));
+        post_message(new Message(SPICE_MSGC_MAIN_ATTACH_CHANNELS, 0));
         _application.deactivate_interval_timer(*_agent_timer);
         break;
     default:
@@ -830,7 +830,7 @@ void RedClient::handle_agent_data(RedPeer::InMessage* message)
 
 void RedClient::handle_agent_tokens(RedPeer::InMessage* message)
 {
-    RedAgentTokens *token = (RedAgentTokens *)message->data();
+    SpiceMsgMainAgentTokens *token = (SpiceMsgMainAgentTokens *)message->data();
     _agent_tokens += token->num_tokens;
 }
 
@@ -847,10 +847,10 @@ void RedClient::get_sync_info(uint8_t channel_type, uint8_t channel_id, SyncInfo
     info.message_serial = &_sync_info[channel_type][channel_id];
 }
 
-void RedClient::wait_for_channels(int wait_list_size, RedWaitForChannel* wait_list)
+void RedClient::wait_for_channels(int wait_list_size, SpiceWaitForChannel* wait_list)
 {
     for (int i = 0; i < wait_list_size; i++) {
-        if (wait_list[i].channel_type >= RED_CHANNEL_END) {
+        if (wait_list[i].channel_type >= SPICE_END_CHANNEL) {
             THROW("invalid channel type %u", wait_list[i].channel_type);
         }
         uint64_t& sync_cell = _sync_info[wait_list[i].channel_type][wait_list[i].channel_id];
diff --git a/client/red_client.h b/client/red_client.h
index 7cc700eb..037896ac 100644
--- a/client/red_client.h
+++ b/client/red_client.h
@@ -50,7 +50,7 @@ public:
     Migrate(RedClient& client);
     ~Migrate();
 
-    void start(const RedMigrationBegin* migrate);
+    void start(const SpiceMsgMainMigrationBegin* migrate);
     bool abort();
     void add_channel(MigChannel* channel);
     void clear_channels();
@@ -156,7 +156,7 @@ public:
     RedPeer::ConnectionOptions::Type get_connection_options(uint32_t channel_type);
     RedPeer::HostAuthOptions& get_host_auth_options() { return _host_auth_opt;}
     void get_sync_info(uint8_t channel_type, uint8_t channel_id, SyncInfo& info);
-    void wait_for_channels(int wait_list_size, RedWaitForChannel* wait_list);
+    void wait_for_channels(int wait_list_size, SpiceWaitForChannel* wait_list);
     PixmapCache& get_pixmap_cache() {return _pixmap_cache;}
     uint64_t get_pixmap_cache_size() { return _pixmap_cache_size;}
     void on_display_mode_change();
@@ -235,7 +235,7 @@ private:
     uint64_t _pixmap_cache_size;
     Mutex _sync_lock;
     Condition _sync_condition;
-    uint64_t _sync_info[RED_CHANNEL_END][256];
+    uint64_t _sync_info[SPICE_END_CHANNEL][256];
 
     GlzDecoderWindowDebug _glz_debug;
     GlzDecoderWindow _glz_window;
diff --git a/client/red_drawable.h b/client/red_drawable.h
index eae2e0dd..d2b03f6c 100644
--- a/client/red_drawable.h
+++ b/client/red_drawable.h
@@ -53,13 +53,13 @@ public:
         OP_XOR,
     };
 
-    void copy_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest);
-    void blend_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest);
-    void combine_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest,
+    void copy_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& dest);
+    void blend_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& dest);
+    void combine_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& dest,
                         CombineOP op);
-    void fill_rect(const Rect& rect, rgb32_t color);
-    void frame_rect(const Rect& rect, rgb32_t color);
-    void erase_rect(const Rect& rect, rgb32_t color);
+    void fill_rect(const SpiceRect& rect, rgb32_t color);
+    void frame_rect(const SpiceRect& rect, rgb32_t color);
+    void erase_rect(const SpiceRect& rect, rgb32_t color);
 };
 
 #endif
diff --git a/client/red_gdi_canvas.cpp b/client/red_gdi_canvas.cpp
index 68acd45d..8e50a066 100644
--- a/client/red_gdi_canvas.cpp
+++ b/client/red_gdi_canvas.cpp
@@ -65,7 +65,7 @@ void GDICanvas::create_pixmap(int width, int height)
 void GDICanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
 {
     for (int i = 0; i < (int)region.num_rects; i++) {
-        Rect* r = &region.rects[i];
+        SpiceRect* r = &region.rects[i];
         dest_dc.copy_pixels(*_pixmap, r->left, r->top, *r);
     }
 }
@@ -96,72 +96,72 @@ void GDICanvas::set_access_params(unsigned long base, unsigned long max)
     gdi_canvas_set_access_params(_canvas, base, max);
 }
 
-void GDICanvas::draw_fill(Rect *bbox, Clip *clip, Fill *fill)
+void GDICanvas::draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
 {
     gdi_canvas_draw_fill(_canvas, bbox, clip, fill);
 }
 
-void GDICanvas::draw_text(Rect *bbox, Clip *clip, Text *text)
+void GDICanvas::draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
 {
     gdi_canvas_draw_text(_canvas, bbox, clip, text);
 }
 
-void GDICanvas::draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque)
+void GDICanvas::draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
 {
     gdi_canvas_draw_opaque(_canvas, bbox, clip, opaque);
 }
 
-void GDICanvas::draw_copy(Rect *bbox, Clip *clip, Copy *copy)
+void GDICanvas::draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
 {
     gdi_canvas_draw_copy(_canvas, bbox, clip, copy);
 }
 
-void GDICanvas::draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent)
+void GDICanvas::draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
 {
     gdi_canvas_draw_transparent(_canvas, bbox, clip, transparent);
 }
 
-void GDICanvas::draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+void GDICanvas::draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
 {
     gdi_canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
 }
 
-void GDICanvas::copy_bits(Rect *bbox, Clip *clip, Point *src_pos)
+void GDICanvas::copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     gdi_canvas_copy_bits(_canvas, bbox, clip, src_pos);
 }
 
-void GDICanvas::draw_blend(Rect *bbox, Clip *clip, Blend *blend)
+void GDICanvas::draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
 {
     gdi_canvas_draw_blend(_canvas, bbox, clip, blend);
 }
 
-void GDICanvas::draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness)
+void GDICanvas::draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
 {
     gdi_canvas_draw_blackness(_canvas, bbox, clip, blackness);
 }
 
-void GDICanvas::draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness)
+void GDICanvas::draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
 {
     gdi_canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
 }
 
-void GDICanvas::draw_invers(Rect *bbox, Clip *clip, Invers *invers)
+void GDICanvas::draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
 {
     gdi_canvas_draw_invers(_canvas, bbox, clip, invers);
 }
 
-void GDICanvas::draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3)
+void GDICanvas::draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
 {
     gdi_canvas_draw_rop3(_canvas, bbox, clip, rop3);
 }
 
-void GDICanvas::draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke)
+void GDICanvas::draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
 {
     gdi_canvas_draw_stroke(_canvas, bbox, clip, stroke);
 }
 
-void GDICanvas::put_image(HDC dc, const PixmapHeader& image, const Rect& dest, const QRegion* clip)
+void GDICanvas::put_image(HDC dc, const PixmapHeader& image, const SpiceRect& dest, const QRegion* clip)
 {
     gdi_canvas_put_image(_canvas, dc, &dest, image.data, image.width, image.height, image.stride,
                          clip);
diff --git a/client/red_gdi_canvas.h b/client/red_gdi_canvas.h
index 7fc981e1..6f494340 100644
--- a/client/red_gdi_canvas.h
+++ b/client/red_gdi_canvas.h
@@ -37,26 +37,26 @@ public:
     virtual void copy_pixels(const QRegion& region, RedDrawable* dc,
                              const PixmapHeader* pixmap);
     virtual void copy_pixels(const QRegion& region, RedDrawable& dc);
-    virtual void put_image(HDC dc, const PixmapHeader& image, const Rect& dest,
+    virtual void put_image(HDC dc, const PixmapHeader& image, const SpiceRect& dest,
                            const QRegion* clip);
 
     virtual CanvasType get_pixmap_type();
 
 protected:
     virtual void set_access_params(unsigned long base, unsigned long max);
-    virtual void draw_fill(Rect *bbox, Clip *clip, Fill *fill);
-    virtual void draw_copy(Rect *bbox, Clip *clip, Copy *copy);
-    virtual void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque);
-    virtual void copy_bits(Rect *bbox, Clip *clip, Point *src_pos);
-    virtual void draw_text(Rect *bbox, Clip *clip, Text *text);
-    virtual void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke);
-    virtual void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3);
-    virtual void draw_blend(Rect *bbox, Clip *clip, Blend *blend);
-    virtual void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness);
-    virtual void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness);
-    virtual void draw_invers(Rect *bbox, Clip *clip, Invers *invers);
-    virtual void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent);
-    virtual void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+    virtual void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+    virtual void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+    virtual void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+    virtual void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+    virtual void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
+    virtual void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+    virtual void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+    virtual void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+    virtual void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+    virtual void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+    virtual void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+    virtual void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
+    virtual void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
 
 private:
     void create_pixmap(int width, int height);
diff --git a/client/red_gl_canvas.cpp b/client/red_gl_canvas.cpp
index f08dd4dc..830de035 100644
--- a/client/red_gl_canvas.cpp
+++ b/client/red_gl_canvas.cpp
@@ -70,7 +70,7 @@ void GCanvas::create_pixmap(int width, int height, RedWindow *win,
 void GCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
 {
     for (int i = 0; i < (int)region.num_rects; i++) {
-        Rect* r = &region.rects[i];
+        SpiceRect* r = &region.rects[i];
         dest_dc.copy_pixels(*_pixmap, r->left, r->top, *r);
     }
 }
@@ -105,85 +105,85 @@ void GCanvas::set_access_params(unsigned long base, unsigned long max)
     gl_canvas_set_access_params(_canvas, base, max);
 }
 
-void GCanvas::draw_fill(Rect *bbox, Clip *clip, Fill *fill)
+void GCanvas::draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
 {
     gl_canvas_draw_fill(_canvas, bbox, clip, fill);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_text(Rect *bbox, Clip *clip, Text *text)
+void GCanvas::draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
 {
     gl_canvas_draw_text(_canvas, bbox, clip, text);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque)
+void GCanvas::draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
 {
     gl_canvas_draw_opaque(_canvas, bbox, clip, opaque);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_copy(Rect *bbox, Clip *clip, Copy *copy)
+void GCanvas::draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
 {
     gl_canvas_draw_copy(_canvas, bbox, clip, copy);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent)
+void GCanvas::draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
 {
     gl_canvas_draw_transparent(_canvas, bbox, clip, transparent);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+void GCanvas::draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
 {
     gl_canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::copy_bits(Rect *bbox, Clip *clip, Point *src_pos)
+void GCanvas::copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     gl_canvas_copy_pixels(_canvas, bbox, clip, src_pos);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_blend(Rect *bbox, Clip *clip, Blend *blend)
+void GCanvas::draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
 {
     gl_canvas_draw_blend(_canvas, bbox, clip, blend);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness)
+void GCanvas::draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
 {
     gl_canvas_draw_blackness(_canvas, bbox, clip, blackness);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness)
+void GCanvas::draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
 {
     gl_canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_invers(Rect *bbox, Clip *clip, Invers *invers)
+void GCanvas::draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
 {
     gl_canvas_draw_invers(_canvas, bbox, clip, invers);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3)
+void GCanvas::draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
 {
     gl_canvas_draw_rop3(_canvas, bbox, clip, rop3);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke)
+void GCanvas::draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
 {
     gl_canvas_draw_stroke(_canvas, bbox, clip, stroke);
     _pixmap->update_texture(bbox);
 }
 
-void GCanvas::put_image(const PixmapHeader& image, const Rect& dest,
+void GCanvas::put_image(const PixmapHeader& image, const SpiceRect& dest,
                         const QRegion* clip)
 {
     gl_canvas_put_image(_canvas, &dest, image.data, image.width, image.height,
diff --git a/client/red_gl_canvas.h b/client/red_gl_canvas.h
index 7763cf2b..918aa6c6 100644
--- a/client/red_gl_canvas.h
+++ b/client/red_gl_canvas.h
@@ -39,23 +39,23 @@ public:
     void copy_pixels(const QRegion& region, RedDrawable* dc,
                      const PixmapHeader* pixmap);
     void copy_pixels(const QRegion& region, RedDrawable& dc);
-    void put_image(const PixmapHeader& image, const Rect& dest,
+    void put_image(const PixmapHeader& image, const SpiceRect& dest,
                    const QRegion* clip);
 
     void set_access_params(unsigned long base, unsigned long max);
-    void draw_fill(Rect *bbox, Clip *clip, Fill *fill);
-    void draw_copy(Rect *bbox, Clip *clip, Copy *copy);
-    void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque);
-    void copy_bits(Rect *bbox, Clip *clip, Point *src_pos);
-    void draw_text(Rect *bbox, Clip *clip, Text *text);
-    void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke);
-    void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3);
-    void draw_blend(Rect *bbox, Clip *clip, Blend *blend);
-    void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness);
-    void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness);
-    void draw_invers(Rect *bbox, Clip *clip, Invers *invers);
-    void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent);
-    void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+    void draw_fill(SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+    void draw_copy(SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+    void draw_opaque(SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+    void copy_bits(SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+    void draw_text(SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
+    void draw_stroke(SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+    void draw_rop3(SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+    void draw_blend(SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+    void draw_blackness(SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+    void draw_whiteness(SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+    void draw_invers(SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+    void draw_transparent(SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
+    void draw_alpha_blend(SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
 
     virtual void textures_lost();
     virtual CanvasType get_pixmap_type();
diff --git a/client/red_peer.cpp b/client/red_peer.cpp
index 0fd60242..f12be5a6 100644
--- a/client/red_peer.cpp
+++ b/client/red_peer.cpp
@@ -658,10 +658,10 @@ uint32_t RedPeer::recive(uint8_t *buf, uint32_t size)
 
 RedPeer::CompundInMessage* RedPeer::recive()
 {
-    RedDataHeader header;
+    SpiceDataHeader header;
     AutoRef<CompundInMessage> message;
 
-    recive((uint8_t*)&header, sizeof(RedDataHeader));
+    recive((uint8_t*)&header, sizeof(SpiceDataHeader));
     message.reset(new CompundInMessage(header.serial, header.type, header.size, header.sub_list));
     recive((*message)->data(), (*message)->compund_size());
     return message.release();
@@ -729,7 +729,7 @@ uint32_t RedPeer::send(RedPeer::OutMessage& message)
 }
 
 RedPeer::OutMessage::OutMessage(uint32_t type, uint32_t size)
-    : _data (new uint8_t[size + sizeof(RedDataHeader)])
+    : _data (new uint8_t[size + sizeof(SpiceDataHeader)])
     , _size (size)
 {
     header().type = type;
@@ -751,7 +751,7 @@ void RedPeer::OutMessage::resize(uint32_t size)
     delete[] _data;
     _data = NULL;
     _size = 0;
-    _data = new uint8_t[size + sizeof(RedDataHeader)];
+    _data = new uint8_t[size + sizeof(SpiceDataHeader)];
     _size = size;
     header().type = type;
     header().size = size;
diff --git a/client/red_peer.h b/client/red_peer.h
index 8a4060df..8b10a5ec 100644
--- a/client/red_peer.h
+++ b/client/red_peer.h
@@ -196,12 +196,12 @@ public:
     OutMessage(uint32_t type, uint32_t size);
     virtual ~OutMessage();
 
-    RedDataHeader& header() { return *(RedDataHeader *)_data;}
-    uint8_t* data() { return _data + sizeof(RedDataHeader);}
+    SpiceDataHeader& header() { return *(SpiceDataHeader *)_data;}
+    uint8_t* data() { return _data + sizeof(SpiceDataHeader);}
     void resize(uint32_t size);
 
 private:
-    uint32_t message_size() { return header().size + sizeof(RedDataHeader);}
+    uint32_t message_size() { return header().size + sizeof(SpiceDataHeader);}
     uint8_t* base() { return _data;}
 
 private:
diff --git a/client/red_pixmap.h b/client/red_pixmap.h
index 5b9ac09a..e09f0f71 100644
--- a/client/red_pixmap.h
+++ b/client/red_pixmap.h
@@ -32,7 +32,7 @@ public:
               rgb32_t* pallete);
     virtual ~RedPixmap();
 
-    virtual Point get_size() { Point pt = {_width, _height}; return pt;}
+    virtual SpicePoint get_size() { SpicePoint pt = {_width, _height}; return pt;}
 
     int get_width() { return _width;}
     int get_height() { return _height;}
diff --git a/client/red_pixmap_gl.h b/client/red_pixmap_gl.h
index d86ddb47..1c0e4229 100644
--- a/client/red_pixmap_gl.h
+++ b/client/red_pixmap_gl.h
@@ -33,7 +33,7 @@ public:
 
     void textures_lost();
     void touch_context();
-    void update_texture(const Rect *bbox);
+    void update_texture(const SpiceRect *bbox);
     void pre_copy();
     void past_copy();
     ~RedPixmapGL();
diff --git a/client/red_window.h b/client/red_window.h
index 377d99be..707b9027 100644
--- a/client/red_window.h
+++ b/client/red_window.h
@@ -57,9 +57,9 @@ public:
         TYPE_FULLSCREEN,
     };
     void set_type(Type type) { _type = type;}
-    Point get_position();
-    virtual Point get_size();
-    bool get_mouse_anchor_point(Point& pt);
+    SpicePoint get_position();
+    virtual SpicePoint get_size();
+    bool get_mouse_anchor_point(SpicePoint& pt);
 
     void set_mouse_position(int x, int y);
     void set_cursor(LocalCursor* local_cursor);
@@ -101,7 +101,7 @@ private:
 
 private:
     Listener& _listener;
-    Point _window_size;
+    SpicePoint _window_size;
     Type _type;
     LocalCursor* _local_cursor;
     bool _cursor_visible;
@@ -115,13 +115,13 @@ private:
 class RedWindow::Listener {
 public:
     virtual ~Listener() {}
-    virtual void on_exposed_rect(const Rect& area) = 0;
+    virtual void on_exposed_rect(const SpiceRect& area) = 0;
 
     virtual void on_pointer_enter(int x, int y, unsigned int buttons_state) = 0;
     virtual void on_pointer_motion(int x, int y, unsigned int buttons_state) = 0;
     virtual void on_pointer_leave() = 0;
-    virtual void on_mouse_button_press(RedButton button, unsigned int buttons_state) = 0;
-    virtual void on_mouse_button_release(RedButton button, unsigned int buttons_state) = 0;
+    virtual void on_mouse_button_press(SpiceMouseButton button, unsigned int buttons_state) = 0;
+    virtual void on_mouse_button_release(SpiceMouseButton button, unsigned int buttons_state) = 0;
 
     virtual void on_key_press(RedKey key) = 0;
     virtual void on_key_release(RedKey key) = 0;
@@ -140,18 +140,18 @@ public:
 };
 
 /*class REGION {
-    void get_bbox(Rect& bbox) const;
+    void get_bbox(SpiceRect& bbox) const;
     bool contains_point(int x, int y) const;
 
 };*/
 
 template <class REGION>
-static bool find_anchor_point(const REGION& region, Point& pt)
+static bool find_anchor_point(const REGION& region, SpicePoint& pt)
 {
     static const unsigned int lookup_size = 20;
     unsigned int width;
     unsigned int height;
-    Rect bbox;
+    SpiceRect bbox;
 
     region.get_bbox(bbox);
     width = bbox.right - bbox.left;
@@ -173,7 +173,7 @@ static bool find_anchor_point(const REGION& region, Point& pt)
                     continue;
                 }
 
-                Rect r;
+                SpiceRect r;
                 r.left = bbox.left + x - lookup_size / 2;
                 r.right = r.left + lookup_size;
                 r.top = bbox.top + y - lookup_size / 2;
diff --git a/client/screen.cpp b/client/screen.cpp
index 29b40bf6..9e6b04ee 100644
--- a/client/screen.cpp
+++ b/client/screen.cpp
@@ -289,7 +289,7 @@ void RedScreen::detach_layer(ScreenLayer& layer)
 void RedScreen::composit_to_screen(RedDrawable& win_dc, const QRegion& region)
 {
     for (int i = 0; i < (int)region.num_rects; i++) {
-        Rect* r = &region.rects[i];
+        SpiceRect* r = &region.rects[i];
         win_dc.copy_pixels(*_composit_area, r->left, r->top, *r);
     }
 }
@@ -315,7 +315,7 @@ inline void RedScreen::begin_update(QRegion& direct_rgn, QRegion& composit_rgn,
     lock.unlock();
 
     QRegion rect_rgn;
-    Rect r;
+    SpiceRect r;
     r.top = r.left = 0;
     r.right = _size.x;
     r.bottom = _size.y;
@@ -445,7 +445,7 @@ void RedScreen::update()
     }
 }
 
-bool RedScreen::_invalidate(const Rect& rect, bool urgent, uint64_t& update_mark)
+bool RedScreen::_invalidate(const SpiceRect& rect, bool urgent, uint64_t& update_mark)
 {
     RecurciveLock lock(_update_lock);
     bool update_triger = !is_dirty() && (urgent || !_periodic_update);
@@ -454,7 +454,7 @@ bool RedScreen::_invalidate(const Rect& rect, bool urgent, uint64_t& update_mark
     return update_triger;
 }
 
-uint64_t RedScreen::invalidate(const Rect& rect, bool urgent)
+uint64_t RedScreen::invalidate(const SpiceRect& rect, bool urgent)
 {
     uint64_t update_mark;
     if (_invalidate(rect, urgent, update_mark)) {
@@ -474,8 +474,8 @@ uint64_t RedScreen::invalidate(const Rect& rect, bool urgent)
 
 void RedScreen::invalidate(const QRegion &region)
 {
-    Rect *r = region.rects;
-    Rect *end = r + region.num_rects;
+    SpiceRect *r = region.rects;
+    SpiceRect *end = r + region.num_rects;
     while (r != end) {
         invalidate(*r++, false);
     }
@@ -631,7 +631,7 @@ void RedScreen::on_pointer_motion(int x, int y, unsigned int buttons_state)
     _pointer_layer->on_pointer_motion(x, y, buttons_state);
 }
 
-void RedScreen::on_mouse_button_press(RedButton button, unsigned int buttons_state)
+void RedScreen::on_mouse_button_press(SpiceMouseButton button, unsigned int buttons_state)
 {
     if (_mouse_captured) {
         _owner.on_mouse_down(button, buttons_state);
@@ -645,7 +645,7 @@ void RedScreen::on_mouse_button_press(RedButton button, unsigned int buttons_sta
     _pointer_layer->on_mouse_button_press(button, buttons_state);
 }
 
-void RedScreen::on_mouse_button_release(RedButton button, unsigned int buttons_state)
+void RedScreen::on_mouse_button_release(SpiceMouseButton button, unsigned int buttons_state)
 {
     if (_mouse_captured) {
         _owner.on_mouse_up(button, buttons_state);
@@ -770,8 +770,8 @@ void RedScreen::__show_full_screen()
         hide();
         return;
     }
-    Point position = _monitor->get_position();
-    Point monitor_size = _monitor->get_size();
+    SpicePoint position = _monitor->get_position();
+    SpicePoint monitor_size = _monitor->get_size();
     _frame_area = false;
     region_clear(&_dirty_region);
     _window.set_type(RedWindow::TYPE_FULLSCREEN);
@@ -807,7 +807,7 @@ void RedScreen::minimize()
     _window.minimize();
 }
 
-void RedScreen::position_full_screen(const Point& position)
+void RedScreen::position_full_screen(const SpicePoint& position)
 {
     if (!_full_screen) {
         return;
@@ -838,7 +838,7 @@ void RedScreen::external_show()
     _window.external_show();
 }
 
-void RedScreen::on_exposed_rect(const Rect& area)
+void RedScreen::on_exposed_rect(const SpiceRect& area)
 {
     if (is_out_of_sync()) {
         _window.fill_rect(area, rgb32_make(0xff, 0xff, 0xff));
diff --git a/client/screen.h b/client/screen.h
index c07d5419..7d29835a 100644
--- a/client/screen.h
+++ b/client/screen.h
@@ -62,13 +62,13 @@ public:
     void on_layer_changed(ScreenLayer& layer);
     void resize(int width, int height);
     void set_name(const std::wstring& name);
-    uint64_t invalidate(const Rect& rect, bool urgent);
+    uint64_t invalidate(const SpiceRect& rect, bool urgent);
     void invalidate(const QRegion &region);
     void capture_mouse();
     void relase_mouse();
     bool is_mouse_captured() { return _mouse_captured;}
     bool intercepts_sys_key() { return _key_interception;}
-    Point get_size() { return _size;}
+    SpicePoint get_size() { return _size;}
     bool has_monitor() { return _monitor != 0;}
     void lock_size();
     void unlock_size();
@@ -82,7 +82,7 @@ public:
     void minimize();
     void show(bool activate, RedScreen* pos);
     void show_full_screen();
-    void position_full_screen(const Point& position);
+    void position_full_screen(const SpicePoint& position);
     void hide();
     void show();
     void activate();
@@ -118,7 +118,7 @@ private:
     bool is_out_of_sync() { return _out_of_sync;}
     void __show_full_screen();
 
-    bool _invalidate(const Rect& rect, bool urgent, uint64_t& update_mark);
+    bool _invalidate(const SpiceRect& rect, bool urgent, uint64_t& update_mark);
     void begin_update(QRegion& direct_rgn, QRegion& composit_rgn, QRegion& frame_rgn);
     void update_composit(QRegion& composit_rgn);
     void draw_direct(RedDrawable& win_dc, QRegion& direct_rgn, QRegion& composit_rgn,
@@ -133,13 +133,13 @@ private:
     ScreenLayer* find_pointer_layer();
     bool update_pointer_layer();
 
-    virtual void on_exposed_rect(const Rect& area);
+    virtual void on_exposed_rect(const SpiceRect& area);
     virtual void on_pointer_enter(int x, int y, unsigned int buttons_state);
     virtual void on_pointer_motion(int x, int y, unsigned int buttons_state);
     virtual void on_pointer_leave();
     void on_mouse_motion(int x, int y, unsigned int buttons_state);
-    virtual void on_mouse_button_press(RedButton button, unsigned int buttons_state);
-    virtual void on_mouse_button_release(RedButton button, unsigned int buttons_state);
+    virtual void on_mouse_button_press(SpiceMouseButton button, unsigned int buttons_state);
+    virtual void on_mouse_button_release(SpiceMouseButton button, unsigned int buttons_state);
 
     virtual void on_key_press(RedKey key);
     virtual void on_key_release(RedKey key);
@@ -178,10 +178,10 @@ private:
     RedDrawable* _composit_area;
     uint64_t _update_mark;
 
-    Point _size;
-    Point _origin;
-    Point _mouse_anchor_point;
-    Point _save_pos;
+    SpicePoint _size;
+    SpicePoint _origin;
+    SpicePoint _mouse_anchor_point;
+    SpicePoint _save_pos;
     Monitor* _monitor;
 
     LocalCursor* _default_cursor;
@@ -195,7 +195,7 @@ private:
     Mutex _layer_changed_lock;
     bool _active_layer_change_event;
     bool _pointer_on_screen;
-    Point _pointer_pos;
+    SpicePoint _pointer_pos;
     unsigned int _mouse_botton_state;
 
     friend class LayerChangedEvent;
diff --git a/client/screen_layer.cpp b/client/screen_layer.cpp
index d4a4435f..af25211e 100644
--- a/client/screen_layer.cpp
+++ b/client/screen_layer.cpp
@@ -78,12 +78,12 @@ ScreenLayer::~ScreenLayer()
     region_destroy(&_composit_area);
 }
 
-uint64_t ScreenLayer::invalidate_rect(const Rect& r, bool urgent)
+uint64_t ScreenLayer::invalidate_rect(const SpiceRect& r, bool urgent)
 {
     return _screen->invalidate(r, urgent);
 }
 
-uint64_t ScreenLayer::invalidate(const Rect& r, bool urgent)
+uint64_t ScreenLayer::invalidate(const SpiceRect& r, bool urgent)
 {
     if (!_screen) {
         return 0;
@@ -96,8 +96,8 @@ void ScreenLayer::invalidate(const QRegion& region)
     if (!_screen) {
         return;
     }
-    Rect *r = region.rects;
-    Rect *end = r + region.num_rects;
+    SpiceRect *r = region.rects;
+    SpiceRect *end = r + region.num_rects;
     while (r != end) {
         invalidate_rect(*r++, false);
     }
@@ -133,7 +133,7 @@ void ScreenLayer::clear_area()
     notify_changed();
 }
 
-void ScreenLayer::set_rect_area(const Rect& r)
+void ScreenLayer::set_rect_area(const SpiceRect& r)
 {
     Lock lock(_area_lock);
     invalidate();
@@ -152,14 +152,14 @@ void ScreenLayer::offset_area(int dx, int dy)
     notify_changed();
 }
 
-void ScreenLayer::add_rect_area(const Rect& r)
+void ScreenLayer::add_rect_area(const SpiceRect& r)
 {
     Lock lock(_area_lock);
     region_add(&_area, &r);
     notify_changed();
 }
 
-void ScreenLayer::remove_rect_area(const Rect& r)
+void ScreenLayer::remove_rect_area(const SpiceRect& r)
 {
     Lock lock(_area_lock);
     invalidate();
diff --git a/client/screen_layer.h b/client/screen_layer.h
index 9b2ed7fa..4966ad4c 100644
--- a/client/screen_layer.h
+++ b/client/screen_layer.h
@@ -38,12 +38,12 @@ public:
     void set_area(const QRegion& area);
     void offset_area(int dx, int dy);
     void clear_area();
-    void set_rect_area(const Rect& r);
-    void add_rect_area(const Rect& r);
-    void remove_rect_area(const Rect& r);
+    void set_rect_area(const SpiceRect& r);
+    void add_rect_area(const SpiceRect& r);
+    void remove_rect_area(const SpiceRect& r);
     void begin_update(QRegion& direct_rgn, QRegion& composit_rgn);
     void invalidate();
-    uint64_t invalidate(const Rect& r, bool urgent = false);
+    uint64_t invalidate(const SpiceRect& r, bool urgent = false);
     void invalidate(const QRegion& r);
     bool contains_point(int x, int y);
 
@@ -70,7 +70,7 @@ public:
     virtual void on_mouse_button_release(int button, int buttons_state) {}
 
 private:
-    uint64_t invalidate_rect(const Rect& r, bool urgent);
+    uint64_t invalidate_rect(const SpiceRect& r, bool urgent);
     void notify_changed();
 
 private:
diff --git a/client/tunnel_channel.cpp b/client/tunnel_channel.cpp
index b6455a61..dd50933d 100644
--- a/client/tunnel_channel.cpp
+++ b/client/tunnel_channel.cpp
@@ -46,7 +46,7 @@ protected:
 private:
     int _refs;
     RedChannel::CompundInMessage& _full_msg;
-    RedTunnelSocketData* _sckt_msg;
+    SpiceMsgTunnelSocketData* _sckt_msg;
     uint32_t _buf_size;
 };
 
@@ -54,10 +54,10 @@ InSocketMessage::InSocketMessage(RedChannel::CompundInMessage& full_msg)
     : _refs (1)
     , _full_msg (full_msg)
 {
-    ASSERT(full_msg.type() == RED_TUNNEL_SOCKET_DATA);
+    ASSERT(full_msg.type() == SPICE_MSG_TUNNEL_SOCKET_DATA);
     _full_msg.ref();
-    _sckt_msg = (RedTunnelSocketData*)(_full_msg.data());
-    _buf_size = _full_msg.size() - sizeof(RedTunnelSocketData);
+    _sckt_msg = (SpiceMsgTunnelSocketData*)(_full_msg.data());
+    _buf_size = _full_msg.size() - sizeof(SpiceMsgTunnelSocketData);
 }
 
 const uint8_t* InSocketMessage::data()
@@ -115,7 +115,7 @@ std::list<OutSocketMessage*> OutSocketMessage::_free_messages;
 uint32_t OutSocketMessage::_max_data_size;
 
 OutSocketMessage::OutSocketMessage()
-    : RedPeer::OutMessage(REDC_TUNNEL_SOCKET_DATA, sizeof(RedcTunnelSocketData) + _max_data_size)
+    : RedPeer::OutMessage(SPICE_MSGC_TUNNEL_SOCKET_DATA, sizeof(SpiceMsgcTunnelSocketData) + _max_data_size)
     , RedChannel::OutMessage()
     , ClientNetSocket::ReceiveBuffer()
 {
@@ -123,12 +123,12 @@ OutSocketMessage::OutSocketMessage()
 
 uint8_t* OutSocketMessage::buf()
 {
-    return ((RedcTunnelSocketData*)RedPeer::OutMessage::data())->data;
+    return ((SpiceMsgcTunnelSocketData*)RedPeer::OutMessage::data())->data;
 }
 
 void OutSocketMessage::set_buf_size(uint32_t size)
 {
-    RedPeer::OutMessage::header().size = size + sizeof(RedcTunnelSocketData);
+    RedPeer::OutMessage::header().size = size + sizeof(SpiceMsgcTunnelSocketData);
 }
 
 void OutSocketMessage::release()
@@ -219,14 +219,14 @@ TunnelChannel::TunnelSocket::TunnelSocket(uint16_t id, TunnelService& dst_servic
 {
 }
 
-class TunnelHandler: public MessageHandlerImp<TunnelChannel, RED_TUNNEL_MESSAGES_END> {
+class TunnelHandler: public MessageHandlerImp<TunnelChannel, SPICE_MSG_END_TUNNEL> {
 public:
     TunnelHandler(TunnelChannel& channel)
-        : MessageHandlerImp<TunnelChannel, RED_TUNNEL_MESSAGES_END>(channel) {}
+        : MessageHandlerImp<TunnelChannel, SPICE_MSG_END_TUNNEL>(channel) {}
 };
 
 TunnelChannel::TunnelChannel(RedClient& client, uint32_t id)
-    : RedChannel(client, RED_CHANNEL_TUNNEL, id, new TunnelHandler(*this))
+    : RedChannel(client, SPICE_CHANNEL_TUNNEL, id, new TunnelHandler(*this))
     , _max_socket_data_size(0)
     , _service_id(0)
     , _service_group(0)
@@ -236,29 +236,29 @@ TunnelChannel::TunnelChannel(RedClient& client, uint32_t id)
 {
     TunnelHandler* handler = static_cast<TunnelHandler*>(get_message_handler());
 
-    handler->set_handler(RED_MIGRATE, &TunnelChannel::handle_migrate, 0);
-    handler->set_handler(RED_SET_ACK, &TunnelChannel::handle_set_ack, sizeof(RedSetAck));
-    handler->set_handler(RED_PING, &TunnelChannel::handle_ping, sizeof(RedPing));
-    handler->set_handler(RED_WAIT_FOR_CHANNELS, &TunnelChannel::handle_wait_for_channels,
-                         sizeof(RedWaitForChannels));
-
-    handler->set_handler(RED_TUNNEL_INIT,
-                         &TunnelChannel::handle_init, sizeof(RedTunnelInit));
-    handler->set_handler(RED_TUNNEL_SERVICE_IP_MAP,
-                         &TunnelChannel::handle_service_ip_map, sizeof(RedTunnelServiceIpMap));
-    handler->set_handler(RED_TUNNEL_SOCKET_OPEN,
-                         &TunnelChannel::handle_socket_open, sizeof(RedTunnelSocketOpen));
-    handler->set_handler(RED_TUNNEL_SOCKET_CLOSE,
-                         &TunnelChannel::handle_socket_close, sizeof(RedTunnelSocketClose));
-    handler->set_handler(RED_TUNNEL_SOCKET_FIN,
-                         &TunnelChannel::handle_socket_fin, sizeof(RedTunnelSocketFin));
-    handler->set_handler(RED_TUNNEL_SOCKET_TOKEN,
-                         &TunnelChannel::handle_socket_token, sizeof(RedTunnelSocketTokens));
-    handler->set_handler(RED_TUNNEL_SOCKET_CLOSED_ACK,
+    handler->set_handler(SPICE_MSG_MIGRATE, &TunnelChannel::handle_migrate, 0);
+    handler->set_handler(SPICE_MSG_SET_ACK, &TunnelChannel::handle_set_ack, sizeof(SpiceMsgSetAck));
+    handler->set_handler(SPICE_MSG_PING, &TunnelChannel::handle_ping, sizeof(SpiceMsgPing));
+    handler->set_handler(SPICE_MSG_WAIT_FOR_CHANNELS, &TunnelChannel::handle_wait_for_channels,
+                         sizeof(SpiceMsgWaitForChannels));
+
+    handler->set_handler(SPICE_MSG_TUNNEL_INIT,
+                         &TunnelChannel::handle_init, sizeof(SpiceMsgTunnelInit));
+    handler->set_handler(SPICE_MSG_TUNNEL_SERVICE_IP_MAP,
+                         &TunnelChannel::handle_service_ip_map, sizeof(SpiceMsgTunnelServiceIpMap));
+    handler->set_handler(SPICE_MSG_TUNNEL_SOCKET_OPEN,
+                         &TunnelChannel::handle_socket_open, sizeof(SpiceMsgTunnelSocketOpen));
+    handler->set_handler(SPICE_MSG_TUNNEL_SOCKET_CLOSE,
+                         &TunnelChannel::handle_socket_close, sizeof(SpiceMsgTunnelSocketClose));
+    handler->set_handler(SPICE_MSG_TUNNEL_SOCKET_FIN,
+                         &TunnelChannel::handle_socket_fin, sizeof(SpiceMsgTunnelSocketFin));
+    handler->set_handler(SPICE_MSG_TUNNEL_SOCKET_TOKEN,
+                         &TunnelChannel::handle_socket_token, sizeof(SpiceMsgTunnelSocketTokens));
+    handler->set_handler(SPICE_MSG_TUNNEL_SOCKET_CLOSED_ACK,
                          &TunnelChannel::handle_socket_closed_ack,
-                         sizeof(RedTunnelSocketClosedAck));
-    handler->set_handler(RED_TUNNEL_SOCKET_DATA,
-                         &TunnelChannel::handle_socket_data, sizeof(RedTunnelSocketData));
+                         sizeof(SpiceMsgTunnelSocketClosedAck));
+    handler->set_handler(SPICE_MSG_TUNNEL_SOCKET_DATA,
+                         &TunnelChannel::handle_socket_data, sizeof(SpiceMsgTunnelSocketData));
 }
 
 TunnelChannel::~TunnelChannel()
@@ -269,7 +269,7 @@ TunnelChannel::~TunnelChannel()
 
 void TunnelChannel::handle_init(RedPeer::InMessage* message)
 {
-    RedTunnelInit* init_msg = (RedTunnelInit*)message->data();
+    SpiceMsgTunnelInit* init_msg = (SpiceMsgTunnelInit*)message->data();
     _max_socket_data_size = init_msg->max_socket_data_size;
     OutSocketMessage::init(_max_socket_data_size);
     _sockets.resize(init_msg->max_num_of_sockets);
@@ -281,29 +281,29 @@ void TunnelChannel::send_service(TunnelService& service)
     msg_size += service.name.length() + 1;
     msg_size += service.description.length() + 1;
 
-    if (service.type == RED_TUNNEL_SERVICE_TYPE_IPP) {
-        msg_size += sizeof(RedcTunnelAddPrintService) + sizeof(RedTunnelIPv4);
-    } else if (service.type == RED_TUNNEL_SERVICE_TYPE_GENERIC) {
-        msg_size += sizeof(RedcTunnelAddGenericService);
+    if (service.type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
+        msg_size += sizeof(SpiceMsgcTunnelAddPrintService) + sizeof(SpiceTunnelIPv4);
+    } else if (service.type == SPICE_TUNNEL_SERVICE_TYPE_GENERIC) {
+        msg_size += sizeof(SpiceMsgcTunnelAddGenericService);
     } else {
         THROW("%s: invalid service type", __FUNCTION__);
     }
-    Message* service_msg = new Message(REDC_TUNNEL_SERVICE_ADD, msg_size);
-    RedcTunnelAddGenericService* out_service = (RedcTunnelAddGenericService*)service_msg->data();
+    Message* service_msg = new Message(SPICE_MSGC_TUNNEL_SERVICE_ADD, msg_size);
+    SpiceMsgcTunnelAddGenericService* out_service = (SpiceMsgcTunnelAddGenericService*)service_msg->data();
     out_service->id = service.id;
     out_service->group = service.group;
     out_service->type = service.type;
     out_service->port = service.port;
 
     int cur_offset;
-    if (service.type == RED_TUNNEL_SERVICE_TYPE_IPP) {
-        cur_offset = sizeof(RedcTunnelAddPrintService);
-        ((RedcTunnelAddPrintService*)out_service)->ip.type = RED_TUNNEL_IP_TYPE_IPv4;
-        memcpy(((RedcTunnelAddPrintService*)out_service)->ip.data, &(service.ip.s_addr),
-               sizeof(RedTunnelIPv4));
-        cur_offset += sizeof(RedTunnelIPv4);
+    if (service.type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
+        cur_offset = sizeof(SpiceMsgcTunnelAddPrintService);
+        ((SpiceMsgcTunnelAddPrintService*)out_service)->ip.type = SPICE_TUNNEL_IP_TYPE_IPv4;
+        memcpy(((SpiceMsgcTunnelAddPrintService*)out_service)->ip.data, &(service.ip.s_addr),
+               sizeof(SpiceTunnelIPv4));
+        cur_offset += sizeof(SpiceTunnelIPv4);
     } else {
-        cur_offset = sizeof(RedcTunnelAddGenericService);
+        cur_offset = sizeof(SpiceMsgcTunnelAddGenericService);
     }
 
     out_service->name = cur_offset;
@@ -322,16 +322,16 @@ void TunnelChannel::send_service(TunnelService& service)
 
 void TunnelChannel::handle_service_ip_map(RedPeer::InMessage* message)
 {
-    RedTunnelServiceIpMap* service_ip_msg = (RedTunnelServiceIpMap*)message->data();
+    SpiceMsgTunnelServiceIpMap* service_ip_msg = (SpiceMsgTunnelServiceIpMap*)message->data();
     TunnelService* service = find_service(service_ip_msg->service_id);
     if (!service) {
         THROW("%s: attempt to map non-existing service id=%d", __FUNCTION__,
               service_ip_msg->service_id);
     }
 
-    if (service_ip_msg->virtual_ip.type == RED_TUNNEL_IP_TYPE_IPv4) {
+    if (service_ip_msg->virtual_ip.type == SPICE_TUNNEL_IP_TYPE_IPv4) {
         memcpy(&service->virtual_ip.s_addr, service_ip_msg->virtual_ip.data,
-               sizeof(RedTunnelIPv4));
+               sizeof(SpiceTunnelIPv4));
     } else {
         THROW("unexpected ip type %d", service_ip_msg->virtual_ip.type);
     }
@@ -344,7 +344,7 @@ void TunnelChannel::handle_service_ip_map(RedPeer::InMessage* message)
 
 void TunnelChannel::handle_socket_open(RedPeer::InMessage* message)
 {
-    RedTunnelSocketOpen* open_msg = (RedTunnelSocketOpen*)message->data();
+    SpiceMsgTunnelSocketOpen* open_msg = (SpiceMsgTunnelSocketOpen*)message->data();
     TunnelSocket* sckt;
     Message* out_msg;
 
@@ -363,15 +363,15 @@ void TunnelChannel::handle_socket_open(RedPeer::InMessage* message)
 
     if (sckt->connect(open_msg->tokens)) {
         _sockets[open_msg->connection_id] = sckt;
-        out_msg = new Message(REDC_TUNNEL_SOCKET_OPEN_ACK, sizeof(RedcTunnelSocketOpenAck));
+        out_msg = new Message(SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK, sizeof(SpiceMsgcTunnelSocketOpenAck));
         sckt->set_num_tokens(0);
         sckt->set_server_num_tokens(SOCKET_WINDOW_SIZE);
 
-        ((RedcTunnelSocketOpenAck*)out_msg->data())->connection_id = open_msg->connection_id;
-        ((RedcTunnelSocketOpenAck*)out_msg->data())->tokens = SOCKET_WINDOW_SIZE;
+        ((SpiceMsgcTunnelSocketOpenAck*)out_msg->data())->connection_id = open_msg->connection_id;
+        ((SpiceMsgcTunnelSocketOpenAck*)out_msg->data())->tokens = SOCKET_WINDOW_SIZE;
     } else {
-        out_msg = new Message(REDC_TUNNEL_SOCKET_OPEN_NACK, sizeof(RedcTunnelSocketOpenNack));
-        ((RedcTunnelSocketOpenNack*)out_msg->data())->connection_id = open_msg->connection_id;
+        out_msg = new Message(SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK, sizeof(SpiceMsgcTunnelSocketOpenNack));
+        ((SpiceMsgcTunnelSocketOpenNack*)out_msg->data())->connection_id = open_msg->connection_id;
         delete sckt;
     }
 
@@ -380,7 +380,7 @@ void TunnelChannel::handle_socket_open(RedPeer::InMessage* message)
 
 void TunnelChannel::handle_socket_fin(RedPeer::InMessage* message)
 {
-    RedTunnelSocketFin* fin_msg = (RedTunnelSocketFin*)message->data();
+    SpiceMsgTunnelSocketFin* fin_msg = (SpiceMsgTunnelSocketFin*)message->data();
     TunnelSocket* sckt = _sockets[fin_msg->connection_id];
 
     if (!sckt) {
@@ -395,7 +395,7 @@ void TunnelChannel::handle_socket_fin(RedPeer::InMessage* message)
 
 void TunnelChannel::handle_socket_close(RedPeer::InMessage* message)
 {
-    RedTunnelSocketClose* close_msg = (RedTunnelSocketClose*)message->data();
+    SpiceMsgTunnelSocketClose* close_msg = (SpiceMsgTunnelSocketClose*)message->data();
     TunnelSocket* sckt = _sockets[close_msg->connection_id];
 
     if (!sckt) {
@@ -417,7 +417,7 @@ void TunnelChannel::handle_socket_close(RedPeer::InMessage* message)
 
 void TunnelChannel::handle_socket_closed_ack(RedPeer::InMessage* message)
 {
-    RedTunnelSocketClosedAck* close_ack_msg = (RedTunnelSocketClosedAck*)message->data();
+    SpiceMsgTunnelSocketClosedAck* close_ack_msg = (SpiceMsgTunnelSocketClosedAck*)message->data();
     TunnelSocket* sckt = _sockets[close_ack_msg->connection_id];
     if (!sckt) {
         THROW("%s: close ack to connection that doesn't exist id=%d", __FUNCTION__,
@@ -435,7 +435,7 @@ void TunnelChannel::handle_socket_closed_ack(RedPeer::InMessage* message)
 
 void TunnelChannel::handle_socket_data(RedPeer::InMessage* message)
 {
-    RedTunnelSocketData* send_msg = (RedTunnelSocketData*)message->data();
+    SpiceMsgTunnelSocketData* send_msg = (SpiceMsgTunnelSocketData*)message->data();
     TunnelSocket* sckt = _sockets[send_msg->connection_id];
 
     if (!sckt) {
@@ -466,7 +466,7 @@ void TunnelChannel::handle_socket_data(RedPeer::InMessage* message)
 
 void TunnelChannel::handle_socket_token(RedPeer::InMessage* message)
 {
-    RedTunnelSocketTokens* token_msg = (RedTunnelSocketTokens*)message->data();
+    SpiceMsgTunnelSocketTokens* token_msg = (SpiceMsgTunnelSocketTokens*)message->data();
     TunnelSocket* sckt = _sockets[token_msg->connection_id];
 
     if (!sckt) {
@@ -485,16 +485,16 @@ void TunnelChannel::on_socket_message_recv_done(ClientNetSocket& sckt,
     TunnelChannel::TunnelSocket* tunnel_sckt = static_cast<TunnelChannel::TunnelSocket*>(&sckt);
     OutSocketMessage* out_msg = static_cast<OutSocketMessage*>(&buf);
 
-    ((RedcTunnelSocketData*)(out_msg->data()))->connection_id = tunnel_sckt->id();
+    ((SpiceMsgcTunnelSocketData*)(out_msg->data()))->connection_id = tunnel_sckt->id();
     post_message(out_msg);
 }
 
 void TunnelChannel::on_socket_fin_recv(ClientNetSocket& sckt)
 {
     TunnelChannel::TunnelSocket* tunnel_sckt = static_cast<TunnelChannel::TunnelSocket*>(&sckt);
-    Message* out_msg = new Message(REDC_TUNNEL_SOCKET_FIN, sizeof(RedcTunnelSocketFin));
+    Message* out_msg = new Message(SPICE_MSGC_TUNNEL_SOCKET_FIN, sizeof(SpiceMsgcTunnelSocketFin));
     DBG(0, "FIN from client coonection id=%d", tunnel_sckt->id());
-    ((RedcTunnelSocketFin*)out_msg->data())->connection_id = tunnel_sckt->id();
+    ((SpiceMsgcTunnelSocketFin*)out_msg->data())->connection_id = tunnel_sckt->id();
     post_message(out_msg);
 }
 
@@ -505,14 +505,14 @@ void TunnelChannel::on_socket_disconnect(ClientNetSocket& sckt)
     // close intiated by server -> needs ack
     if (tunnel_sckt->get_guest_closed()) {
         DBG(0, "send close ack connection_id=%d", tunnel_sckt->id());
-        out_msg = new Message(REDC_TUNNEL_SOCKET_CLOSED_ACK, sizeof(RedcTunnelSocketClosedAck));
-        ((RedcTunnelSocketClosedAck*)out_msg->data())->connection_id = tunnel_sckt->id();
+        out_msg = new Message(SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK, sizeof(SpiceMsgcTunnelSocketClosedAck));
+        ((SpiceMsgcTunnelSocketClosedAck*)out_msg->data())->connection_id = tunnel_sckt->id();
         _sockets[tunnel_sckt->id()] = NULL;
         delete &sckt;
     } else { // close initiated by client
         DBG(0, "send close coonection_id=%d", tunnel_sckt->id());
-        out_msg = new Message(REDC_TUNNEL_SOCKET_CLOSED, sizeof(RedcTunnelSocketClosed));
-        ((RedcTunnelSocketClosed*)out_msg->data())->connection_id = tunnel_sckt->id();
+        out_msg = new Message(SPICE_MSGC_TUNNEL_SOCKET_CLOSED, sizeof(SpiceMsgcTunnelSocketClosed));
+        ((SpiceMsgcTunnelSocketClosed*)out_msg->data())->connection_id = tunnel_sckt->id();
     }
 
     post_message(out_msg);
@@ -525,8 +525,8 @@ void TunnelChannel::on_socket_message_send_done(ClientNetSocket& sckt)
     num_tokens++;
 
     if (num_tokens == SOCKET_TOKENS_TO_SEND) {
-        Message* out_msg = new Message(REDC_TUNNEL_SOCKET_TOKEN, sizeof(RedcTunnelSocketTokens));
-        RedcTunnelSocketTokens* tokens_msg = (RedcTunnelSocketTokens*)out_msg->data();
+        Message* out_msg = new Message(SPICE_MSGC_TUNNEL_SOCKET_TOKEN, sizeof(SpiceMsgcTunnelSocketTokens));
+        SpiceMsgcTunnelSocketTokens* tokens_msg = (SpiceMsgcTunnelSocketTokens*)out_msg->data();
         tokens_msg->connection_id = tunnel_sckt->id();
         tokens_msg->num_tokens = num_tokens;
         post_message(out_msg);
@@ -641,7 +641,7 @@ void TunnelChannel::add_service(TunnelConfigConnectionIfc& source,
 
 class TunnelFactory: public ChannelFactory {
 public:
-    TunnelFactory() : ChannelFactory(RED_CHANNEL_TUNNEL) {}
+    TunnelFactory() : ChannelFactory(SPICE_CHANNEL_TUNNEL) {}
     virtual RedChannel* construct(RedClient& client, uint32_t id)
     {
         return new TunnelChannel(client, id);
@@ -823,9 +823,9 @@ void TunnelConfigConnectionIfc::handle_msg()
         THROW("unexpected service type length");
     }
     if (msg[start_token] == '0') {
-        service_type = RED_TUNNEL_SERVICE_TYPE_GENERIC;
+        service_type = SPICE_TUNNEL_SERVICE_TYPE_GENERIC;
     } else if (msg[start_token] == '1') {
-        service_type = RED_TUNNEL_SERVICE_TYPE_IPP;
+        service_type = SPICE_TUNNEL_SERVICE_TYPE_IPP;
     } else {
         THROW("unexpected service type");
     }
diff --git a/client/windows/pixels_source.cpp b/client/windows/pixels_source.cpp
index 6d210f09..178b88fd 100644
--- a/client/windows/pixels_source.cpp
+++ b/client/windows/pixels_source.cpp
@@ -23,10 +23,10 @@
 #include "debug.h"
 
 
-static Point get_bitmap_size(HDC dc)
+static SpicePoint get_bitmap_size(HDC dc)
 {
     BITMAP bitmap_info;
-    Point size;
+    SpicePoint size;
 
     GetObject(GetCurrentObject(dc, OBJ_BITMAP), sizeof(bitmap_info), &bitmap_info);
 
@@ -74,7 +74,7 @@ ImageFromRes::~ImageFromRes()
     }
 }
 
-Point ImageFromRes::get_size()
+SpicePoint ImageFromRes::get_size()
 {
     ResImage_p* p_data = (ResImage_p*)get_opaque();
     Lock lock(*p_data->source_p._mutex);
@@ -99,7 +99,7 @@ AlphaImageFromRes::~AlphaImageFromRes()
     }
 }
 
-Point AlphaImageFromRes::get_size()
+SpicePoint AlphaImageFromRes::get_size()
 {
     ResImage_p* p_data = (ResImage_p*)get_opaque();
     Lock lock(*p_data->source_p._mutex);
diff --git a/client/windows/platform.cpp b/client/windows/platform.cpp
index c364b35d..5b31798c 100644
--- a/client/windows/platform.cpp
+++ b/client/windows/platform.cpp
@@ -233,8 +233,8 @@ public:
     WinMonitor(int id, const wchar_t* name, const wchar_t* string);
 
     virtual int get_depth() { return _depth;}
-    virtual Point get_position();
-    virtual Point get_size() const { Point size = {_width, _height}; return size;}
+    virtual SpicePoint get_position();
+    virtual SpicePoint get_size() const { SpicePoint size = {_width, _height}; return size;}
     virtual bool is_out_of_sync() { return _out_of_sync;}
     virtual int get_screen_id() { return 0;}
 
@@ -252,7 +252,7 @@ private:
     std::wstring _dev_name;
     std::wstring _dev_string;
     bool _active;
-    Point _position;
+    SpicePoint _position;
     int _width;
     int _height;
     int _depth;
@@ -287,7 +287,7 @@ void WinMonitor::update_position()
     _depth = mode.dmBitsPerPel;
 }
 
-Point WinMonitor::get_position()
+SpicePoint WinMonitor::get_position()
 {
     update_position();
     return _position;
@@ -546,8 +546,8 @@ void Platform::reset_cursor_pos()
     if (!primary_monitor) {
         return;
     }
-    Point pos =  primary_monitor->get_position();
-    Point size =  primary_monitor->get_size();
+    SpicePoint pos =  primary_monitor->get_position();
+    SpicePoint size =  primary_monitor->get_size();
     SetCursorPos(pos.x + size.x / 2, pos.y + size.y / 2);
 }
 
@@ -572,14 +572,14 @@ private:
 WinLocalCursor::WinLocalCursor(CursorData* cursor_data)
     : _shared (false)
 {
-    const CursorHeader& header = cursor_data->header();
+    const SpiceCursorHeader& header = cursor_data->header();
     const uint8_t* data = cursor_data->data();
     int cur_size;
     int bits = get_size_bits(header, cur_size);
     if (!bits) {
         THROW("invalid curosr type");
     }
-    if (header.type == CURSOR_TYPE_MONO) {
+    if (header.type == SPICE_CURSOR_TYPE_MONO) {
         _handle = CreateCursor(NULL, header.hot_spot_x, header.hot_spot_y,
                                header.width, header.height, data, data + cur_size);
         return;
@@ -592,9 +592,9 @@ WinLocalCursor::WinLocalCursor(CursorData* cursor_data)
     HDC hdc = GetDC(NULL);
 
     switch (header.type) {
-    case CURSOR_TYPE_ALPHA:
-    case CURSOR_TYPE_COLOR32:
-    case CURSOR_TYPE_COLOR16: {
+    case SPICE_CURSOR_TYPE_ALPHA:
+    case SPICE_CURSOR_TYPE_COLOR32:
+    case SPICE_CURSOR_TYPE_COLOR16: {
         BITMAPV5HEADER bmp_hdr;
         ZeroMemory(&bmp_hdr, sizeof(bmp_hdr));
         bmp_hdr.bV5Size = sizeof(bmp_hdr);
@@ -612,7 +612,7 @@ WinLocalCursor::WinLocalCursor(CursorData* cursor_data)
             bmp_hdr.bV5GreenMask = 0x000003E0;
             bmp_hdr.bV5BlueMask  = 0x0000001F;
         }
-        if (header.type == CURSOR_TYPE_ALPHA) {
+        if (header.type == SPICE_CURSOR_TYPE_ALPHA) {
             bmp_hdr.bV5AlphaMask = 0xFF000000;
         }
         void* bmp_pixels = NULL;
@@ -620,11 +620,11 @@ WinLocalCursor::WinLocalCursor(CursorData* cursor_data)
                                          NULL, 0);
         memcpy(bmp_pixels, data, cur_size);
         icon.hbmMask = CreateBitmap(header.width, header.height, 1, 1,
-                                    (header.type == CURSOR_TYPE_ALPHA) ? NULL :
+                                    (header.type == SPICE_CURSOR_TYPE_ALPHA) ? NULL :
                                                                    (CONST VOID *)(data + cur_size));
         break;
     }
-    case CURSOR_TYPE_COLOR4: {
+    case SPICE_CURSOR_TYPE_COLOR4: {
         BITMAPINFO* bmp_info;
         bmp_info = (BITMAPINFO *)new uint8_t[sizeof(BITMAPINFO) + (sizeof(RGBQUAD) << bits)];
         ZeroMemory(bmp_info, sizeof(BITMAPINFO));
@@ -642,8 +642,8 @@ WinLocalCursor::WinLocalCursor(CursorData* cursor_data)
         delete[] (uint8_t *)bmp_info;
         break;
     }
-    case CURSOR_TYPE_COLOR24:
-    case CURSOR_TYPE_COLOR8:
+    case SPICE_CURSOR_TYPE_COLOR24:
+    case SPICE_CURSOR_TYPE_COLOR8:
     default:
         LOG_WARN("unsupported cursor type %d", header.type);
         _handle = LoadCursor(NULL, IDC_ARROW);
diff --git a/client/windows/red_drawable.cpp b/client/windows/red_drawable.cpp
index 13d4a21e..cac7299e 100644
--- a/client/windows/red_drawable.cpp
+++ b/client/windows/red_drawable.cpp
@@ -23,7 +23,7 @@
 
 static const uint64_t lock_timout = 1000 * 1000 * 10; /*10ms*/
 
-void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest)
+void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& dest)
 {
     PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
     PixelsSource_p* src_p_data = (PixelsSource_p*)src.get_opaque();
@@ -42,7 +42,7 @@ void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, con
     }
 }
 
-void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest)
+void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& dest)
 {
     static BLENDFUNCTION blend_func = { AC_SRC_OVER, 0, 0xff, AC_SRC_ALPHA};
 
@@ -63,7 +63,7 @@ void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, co
     }
 }
 
-void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest,
+void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& dest,
                                  CombineOP op)
 {
     DWORD rop;
@@ -97,7 +97,7 @@ void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y,
     }
 }
 
-void RedDrawable::erase_rect(const Rect& rect, rgb32_t color)
+void RedDrawable::erase_rect(const SpiceRect& rect, rgb32_t color)
 {
     RECT r;
     r.left = rect.left + _origin.x;
@@ -110,7 +110,7 @@ void RedDrawable::erase_rect(const Rect& rect, rgb32_t color)
     FillRect(dest_p_data->dc, &r, (HBRUSH)GetStockObject(BLACK_BRUSH));
 }
 
-void RedDrawable::fill_rect(const Rect& rect, rgb32_t color)
+void RedDrawable::fill_rect(const SpiceRect& rect, rgb32_t color)
 {
     RECT r;
     r.left = rect.left + _origin.x;
@@ -130,7 +130,7 @@ void RedDrawable::fill_rect(const Rect& rect, rgb32_t color)
     DeleteObject(brush);
 }
 
-void RedDrawable::frame_rect(const Rect& rect, rgb32_t color)
+void RedDrawable::frame_rect(const SpiceRect& rect, rgb32_t color)
 {
     RECT r;
     r.left = rect.left + _origin.x;
diff --git a/client/windows/red_window.cpp b/client/windows/red_window.cpp
index 2d415d1e..a2522d9f 100644
--- a/client/windows/red_window.cpp
+++ b/client/windows/red_window.cpp
@@ -44,9 +44,9 @@ static LRESULT CALLBACK MessageFilterProc(int nCode, WPARAM wParam, LPARAM lPara
 
 static inline int to_red_mouse_state(WPARAM wParam)
 {
-    return ((wParam & MK_LBUTTON) ? REDC_LBUTTON_MASK : 0) |
-           ((wParam & MK_MBUTTON) ? REDC_MBUTTON_MASK : 0) |
-           ((wParam & MK_RBUTTON) ? REDC_RBUTTON_MASK : 0);
+    return ((wParam & MK_LBUTTON) ? SPICE_MOUSE_BUTTON_MASK_LEFT : 0) |
+           ((wParam & MK_MBUTTON) ? SPICE_MOUSE_BUTTON_MASK_MIDDLE : 0) |
+           ((wParam & MK_RBUTTON) ? SPICE_MOUSE_BUTTON_MASK_RIGHT : 0);
 }
 
 static inline RedKey translate_key(int virtual_key, uint32_t scan, bool escape)
@@ -146,8 +146,8 @@ LRESULT CALLBACK RedWindow_p::WindowProc(HWND hWnd, UINT message, WPARAM wParam,
         HDC hdc;
 
         hdc = BeginPaint(hWnd, &ps);
-        Point origin = window->get_origin();
-        Rect r;
+        SpicePoint origin = window->get_origin();
+        SpiceRect r;
         r.left = ps.rcPaint.left - origin.x;
         r.top = ps.rcPaint.top - origin.y;
         r.right = ps.rcPaint.right - origin.x;
@@ -157,7 +157,7 @@ LRESULT CALLBACK RedWindow_p::WindowProc(HWND hWnd, UINT message, WPARAM wParam,
         break;
     }
     case WM_MOUSEMOVE: {
-        Point origin = window->get_origin();
+        SpicePoint origin = window->get_origin();
         int x = LOWORD(lParam) - origin.x;
         int y = HIWORD(lParam) - origin.y;
         unsigned int buttons_state = to_red_mouse_state(wParam);
@@ -178,39 +178,39 @@ LRESULT CALLBACK RedWindow_p::WindowProc(HWND hWnd, UINT message, WPARAM wParam,
         window->on_focus_out();
         break;
     case WM_LBUTTONDOWN:
-        window->get_listener().on_mouse_button_press(REDC_MOUSE_LBUTTON,
+        window->get_listener().on_mouse_button_press(SPICE_MOUSE_BUTTON_LEFT,
                                                      to_red_mouse_state(wParam));
         break;
     case WM_LBUTTONUP:
-        window->get_listener().on_mouse_button_release(REDC_MOUSE_LBUTTON,
+        window->get_listener().on_mouse_button_release(SPICE_MOUSE_BUTTON_LEFT,
                                                        to_red_mouse_state(wParam));
         break;
     case WM_RBUTTONDOWN:
-        window->get_listener().on_mouse_button_press(REDC_MOUSE_RBUTTON,
+        window->get_listener().on_mouse_button_press(SPICE_MOUSE_BUTTON_RIGHT,
                                                      to_red_mouse_state(wParam));
         break;
     case WM_RBUTTONUP:
-        window->get_listener().on_mouse_button_release(REDC_MOUSE_RBUTTON,
+        window->get_listener().on_mouse_button_release(SPICE_MOUSE_BUTTON_RIGHT,
                                                        to_red_mouse_state(wParam));
         break;
     case WM_MBUTTONDOWN:
-        window->get_listener().on_mouse_button_press(REDC_MOUSE_MBUTTON,
+        window->get_listener().on_mouse_button_press(SPICE_MOUSE_BUTTON_MIDDLE,
                                                      to_red_mouse_state(wParam));
         break;
     case WM_MBUTTONUP:
-        window->get_listener().on_mouse_button_release(REDC_MOUSE_MBUTTON,
+        window->get_listener().on_mouse_button_release(SPICE_MOUSE_BUTTON_MIDDLE,
                                                        to_red_mouse_state(wParam));
         break;
     case WM_MOUSEWHEEL:
         if (HIWORD(wParam) & 0x8000) {
-            window->get_listener().on_mouse_button_press(REDC_MOUSE_DBUTTON,
+            window->get_listener().on_mouse_button_press(SPICE_MOUSE_BUTTON_DOWN,
                                                          to_red_mouse_state(wParam));
-            window->get_listener().on_mouse_button_release(REDC_MOUSE_DBUTTON,
+            window->get_listener().on_mouse_button_release(SPICE_MOUSE_BUTTON_DOWN,
                                                            to_red_mouse_state(wParam));
         } else {
-            window->get_listener().on_mouse_button_press(REDC_MOUSE_UBUTTON,
+            window->get_listener().on_mouse_button_press(SPICE_MOUSE_BUTTON_UP,
                                                          to_red_mouse_state(wParam));
-            window->get_listener().on_mouse_button_release(REDC_MOUSE_UBUTTON,
+            window->get_listener().on_mouse_button_release(SPICE_MOUSE_BUTTON_UP,
                                                            to_red_mouse_state(wParam));
         }
         break;
@@ -369,7 +369,7 @@ void RedWindow_p::on_pos_changing(RedWindow& red_window)
     if (_minimized || IsIconic(_win)) {
         return;
     }
-    Point pos = red_window.get_position();
+    SpicePoint pos = red_window.get_position();
     _x = pos.x;
     _y = pos.y;
     _valid_pos = true;
@@ -529,7 +529,7 @@ void RedWindow::hide()
     ShowWindow(_win, SW_HIDE);
 }
 
-static void client_to_window_size(HWND win, int width, int height, Point& win_size,
+static void client_to_window_size(HWND win, int width, int height, SpicePoint& win_size,
                                   RedWindow::Type type)
 {
     RECT area;
@@ -593,7 +593,7 @@ public:
     Region_p(HRGN region) : _region (region) {}
     ~Region_p() {}
 
-    void get_bbox(Rect& bbox) const
+    void get_bbox(SpiceRect& bbox) const
     {
         RECT box;
 
@@ -615,13 +615,13 @@ private:
     HRGN _region;
 };
 
-bool RedWindow::get_mouse_anchor_point(Point& pt)
+bool RedWindow::get_mouse_anchor_point(SpicePoint& pt)
 {
     AutoGDIObject region(CreateRectRgn(0, 0, 0, 0));
     WindowDC win_dc(_win);
 
     GetRandomRgn(*win_dc, (HRGN)region.get(), SYSRGN);
-    Point anchor;
+    SpicePoint anchor;
     Region_p region_p((HRGN)region.get());
     if (!find_anchor_point(region_p, anchor)) {
         return false;
@@ -686,9 +686,9 @@ void RedWindow::show_cursor()
     }
 }
 
-Point RedWindow::get_position()
+SpicePoint RedWindow::get_position()
 {
-    Point position;
+    SpicePoint position;
     if (_minimized || IsIconic(_win)) {
         if (_valid_pos) {
             position.x = _x;
@@ -705,11 +705,11 @@ Point RedWindow::get_position()
     return position;
 }
 
-Point RedWindow::get_size()
+SpicePoint RedWindow::get_size()
 {
     RECT client_rect;
     GetClientRect(_win, &client_rect);
-    Point pt = {client_rect.right - client_rect.left, client_rect.bottom - client_rect.top};
+    SpicePoint pt = {client_rect.right - client_rect.left, client_rect.bottom - client_rect.top};
     return pt;
 }
 
diff --git a/client/x11/pixels_source.cpp b/client/x11/pixels_source.cpp
index d8d8cb75..7b9ed05f 100644
--- a/client/x11/pixels_source.cpp
+++ b/client/x11/pixels_source.cpp
@@ -94,10 +94,10 @@ ImageFromRes::~ImageFromRes()
     delete ((PixelsSource_p*)get_opaque())->pixmap.x_image;
 }
 
-Point ImageFromRes::get_size()
+SpicePoint ImageFromRes::get_size()
 {
     XImage *image = ((PixelsSource_p*)get_opaque())->pixmap.x_image;
-    Point pt;
+    SpicePoint pt;
     pt.x = image->width;
     pt.y = image->height;
     return pt;
@@ -118,10 +118,10 @@ AlphaImageFromRes::~AlphaImageFromRes()
     delete ((PixelsSource_p*)get_opaque())->pixmap.x_image;
 }
 
-Point AlphaImageFromRes::get_size()
+SpicePoint AlphaImageFromRes::get_size()
 {
     XImage *image = ((PixelsSource_p*)get_opaque())->pixmap.x_image;
-    Point pt;
+    SpicePoint pt;
     pt.x = image->width;
     pt.y = image->height;
     return pt;
diff --git a/client/x11/platform.cpp b/client/x11/platform.cpp
index 6aab7992..a41488eb 100644
--- a/client/x11/platform.cpp
+++ b/client/x11/platform.cpp
@@ -478,12 +478,12 @@ public:
     void set_width(int width) {_width = width;}
     int get_height() const { return _height;}
     void set_height(int height) {_height = height;}
-    Point get_position() const {return _position;}
+    SpicePoint get_position() const {return _position;}
 
 private:
     Display* _display;
     int _screen;
-    Point _position;
+    SpicePoint _position;
     int _width;
     int _height;
     bool _broken;
@@ -520,8 +520,8 @@ public:
     }
 
     virtual int get_depth() { return XPlatform::get_vinfo()[0]->depth;}
-    virtual Point get_position() { return XScreen::get_position();}
-    virtual Point get_size() const { Point pt = {get_width(), get_height()}; return pt;}
+    virtual SpicePoint get_position() { return XScreen::get_position();}
+    virtual SpicePoint get_size() const { SpicePoint pt = {get_width(), get_height()}; return pt;}
     virtual bool is_out_of_sync() { return _out_of_sync;}
     virtual int get_screen_id() { return get_screen();}
 
@@ -544,8 +544,8 @@ public:
 
     void publish_monitors(MonitorsList& monitors);
     virtual int get_depth() { return XPlatform::get_vinfo()[0]->depth;}
-    virtual Point get_position() { return XScreen::get_position();}
-    virtual Point get_size() const { Point pt = {get_width(), get_height()}; return pt;}
+    virtual SpicePoint get_position() { return XScreen::get_position();}
+    virtual SpicePoint get_size() const { SpicePoint pt = {get_width(), get_height()}; return pt;}
     virtual bool is_out_of_sync() { return _out_of_sync;}
     virtual int get_screen_id() { return get_screen();}
 
@@ -694,8 +694,8 @@ public:
 private:
     void set_size(int width, int height);
     void get_trans_size(int& width, int& hight);
-    Point get_trans_top_left();
-    Point get_trans_bottom_right();
+    SpicePoint get_trans_top_left();
+    SpicePoint get_trans_bottom_right();
     bool changed();
 
     XMonitor* crtc_overlap_test(int x, int y, int width, int height);
@@ -722,8 +722,8 @@ public:
     virtual ~XMonitor();
 
     virtual int get_depth();
-    virtual Point get_position();
-    virtual Point get_size() const;
+    virtual SpicePoint get_position();
+    virtual SpicePoint get_size() const;
     virtual bool is_out_of_sync();
     virtual int get_screen_id() { return _container.get_screen();}
 
@@ -733,8 +733,8 @@ public:
     void enable();
 
     void set_mode(const XRRModeInfo& mode);
-    const Rect& get_prev_area();
-    Rect& get_trans_area();
+    const SpiceRect& get_prev_area();
+    SpiceRect& get_trans_area();
     void pin() { _pin_count++;}
     void unpin() { ASSERT(_pin_count > 0); _pin_count--;}
     bool is_pinned() {return !!_pin_count;}
@@ -763,15 +763,15 @@ private:
     MultyMonScreen& _container;
     RRCrtc _crtc;
     XMonitorsList _clones;
-    Point _position;
-    Point _size;
+    SpicePoint _position;
+    SpicePoint _size;
     RRMode _mode;
     Rotation _rotation;
     int _noutput;
     RROutput* _outputs;
 
-    Point _saved_position;
-    Point _saved_size;
+    SpicePoint _saved_position;
+    SpicePoint _saved_size;
     RRMode _saved_mode;
     Rotation _saved_rotation;
 
@@ -780,7 +780,7 @@ private:
     RedSubpixelOrder _subpixel_order;
 
     int _trans_depth;
-    Rect _trans_area[MAX_TRANS_DEPTH];
+    SpiceRect _trans_area[MAX_TRANS_DEPTH];
     int _pin_count;
     XMonitor* _pusher;
 };
@@ -852,8 +852,8 @@ XMonitor* MultyMonScreen::crtc_overlap_test(int x, int y, int width, int height)
     for (; iter != _monitors.end(); iter++) {
         XMonitor* mon = *iter;
 
-        Point pos = mon->get_position();
-        Point size = mon->get_size();
+        SpicePoint pos = mon->get_position();
+        SpicePoint size = mon->get_size();
 
         if (x == pos.x && y == pos.y && width == size.x && height == size.y) {
             return mon;
@@ -949,28 +949,28 @@ void MultyMonScreen::restore()
     X_DEBUG_SYNC(get_display());
 }
 
-Point MultyMonScreen::get_trans_top_left()
+SpicePoint MultyMonScreen::get_trans_top_left()
 {
-    Point position;
+    SpicePoint position;
     position.y = position.x = MAXINT;
 
     XMonitorsList::iterator iter = _monitors.begin();
     for (; iter != _monitors.end(); iter++) {
-        Rect& area = (*iter)->get_trans_area();
+        SpiceRect& area = (*iter)->get_trans_area();
         position.x = MIN(position.x, area.left);
         position.y = MIN(position.y, area.top);
     }
     return position;
 }
 
-Point MultyMonScreen::get_trans_bottom_right()
+SpicePoint MultyMonScreen::get_trans_bottom_right()
 {
-    Point position;
+    SpicePoint position;
     position.y = position.x = MININT;
 
     XMonitorsList::iterator iter = _monitors.begin();
     for (; iter != _monitors.end(); iter++) {
-        Rect& area = (*iter)->get_trans_area();
+        SpiceRect& area = (*iter)->get_trans_area();
         position.x = MAX(position.x, area.right);
         position.y = MAX(position.y, area.bottom);
     }
@@ -980,7 +980,7 @@ Point MultyMonScreen::get_trans_bottom_right()
 void MultyMonScreen::get_trans_size(int& width, int& height)
 {
     ASSERT(get_trans_top_left().x == 0 && get_trans_top_left().y == 0);
-    Point bottom_right = get_trans_bottom_right();
+    SpicePoint bottom_right = get_trans_bottom_right();
     ASSERT(bottom_right.x > 0 && bottom_right.y > 0);
     width = bottom_right.x;
     height = bottom_right.y;
@@ -989,17 +989,17 @@ void MultyMonScreen::get_trans_size(int& width, int& height)
 #endif
 
 /*class Variant {
-    static void get_area_in_front(const Rect& base, int size, Rect& area)
-    static int get_push_distance(const Rect& fix_area, const Rect& other)
-    static int get_head(const Rect& area)
-    static int get_tail(const Rect& area)
-    static void move_head(Rect& area, int delta)
-    static int get_pull_distance(const Rect& fix_area, const Rect& other)
-    static void offset(Rect& area, int delta)
-    static void shrink(Rect& area, int delta)
-    static int get_distance(const Rect& area, const Rect& other_area)
-    static bool is_on_tail(const Rect& area, const Rect& other_area)
-    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    static void get_area_in_front(const SpiceRect& base, int size, SpiceRect& area)
+    static int get_push_distance(const SpiceRect& fix_area, const SpiceRect& other)
+    static int get_head(const SpiceRect& area)
+    static int get_tail(const SpiceRect& area)
+    static void move_head(SpiceRect& area, int delta)
+    static int get_pull_distance(const SpiceRect& fix_area, const SpiceRect& other)
+    static void offset(SpiceRect& area, int delta)
+    static void shrink(SpiceRect& area, int delta)
+    static int get_distance(const SpiceRect& area, const SpiceRect& other_area)
+    static bool is_on_tail(const SpiceRect& area, const SpiceRect& other_area)
+    static bool is_on_perpendiculars(const SpiceRect& area, const SpiceRect& other_area)
 }*/
 
 #ifdef USE_XRANDR_1_2
@@ -1017,7 +1017,7 @@ typedef std::multiset<XMonitor*, SortRightToLeft> PushLeftSet;
 class LeftVariant {
 public:
 
-    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    static void get_area_in_front(const SpiceRect& base, int size, SpiceRect& area)
     {
         area.right = base.left;
         area.left = area.right - size;
@@ -1025,55 +1025,55 @@ public:
         area.top = base.top;
     }
 
-    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    static int get_push_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return other.right - fix_area.left;
     }
 
-    static int get_head(const Rect& area)
+    static int get_head(const SpiceRect& area)
     {
         return area.left;
     }
 
-    static int get_tail(const Rect& area)
+    static int get_tail(const SpiceRect& area)
     {
         return area.right;
     }
 
-    static void move_head(Rect& area, int delta)
+    static void move_head(SpiceRect& area, int delta)
     {
         area.left -= delta;
         ASSERT(area.right >= area.left);
     }
 
-    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    static int get_pull_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return other.left - fix_area.right;
     }
 
-    static void offset(Rect& area, int delta)
+    static void offset(SpiceRect& area, int delta)
     {
         rect_offset(area, -delta, 0);
     }
 
-    static void shrink(Rect& area, int delta)
+    static void shrink(SpiceRect& area, int delta)
     {
         area.right -= delta;
         ASSERT(area.right > area.left);
     }
 
-    static int get_distance(const Rect& area, const Rect& other_area)
+    static int get_distance(const SpiceRect& area, const SpiceRect& other_area)
     {
         return other_area.left - area.left;
     }
 
-    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    static bool is_on_tail(const SpiceRect& area, const SpiceRect& other_area)
     {
         return area.right == other_area.left && other_area.top < area.bottom &&
                other_area.bottom > area.top;
     }
 
-    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    static bool is_on_perpendiculars(const SpiceRect& area, const SpiceRect& other_area)
     {
         return (other_area.bottom == area.top || other_area.top == area.bottom) &&
                other_area.left < area.right && other_area.right > area.left;
@@ -1093,7 +1093,7 @@ typedef std::multiset<XMonitor*, SortLeftToRight> PushRightSet;
 class RightVariant {
 public:
 
-    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    static void get_area_in_front(const SpiceRect& base, int size, SpiceRect& area)
     {
         area.left = base.right;
         area.right = area.left + size;
@@ -1101,44 +1101,44 @@ public:
         area.bottom = base.bottom;
     }
 
-    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    static int get_push_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return fix_area.right - other.left;
     }
 
-    static int get_head(const Rect& area)
+    static int get_head(const SpiceRect& area)
     {
         return area.right;
     }
 
-    static int get_tail(const Rect& area)
+    static int get_tail(const SpiceRect& area)
     {
         return area.left;
     }
 
-    static void move_head(Rect& area, int delta)
+    static void move_head(SpiceRect& area, int delta)
     {
         area.right += delta;
         ASSERT(area.right >= area.left);
     }
 
-    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    static int get_pull_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return fix_area.left - other.right;
     }
 
-    static void offset(Rect& area, int delta)
+    static void offset(SpiceRect& area, int delta)
     {
         rect_offset(area, delta, 0);
     }
 
-    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    static bool is_on_tail(const SpiceRect& area, const SpiceRect& other_area)
     {
         return other_area.right == area.left && other_area.top < area.bottom &&
                other_area.bottom > area.top;
     }
 
-    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    static bool is_on_perpendiculars(const SpiceRect& area, const SpiceRect& other_area)
     {
         return (other_area.bottom == area.top || other_area.top == area.bottom) &&
                other_area.left < area.right && other_area.right > area.left;
@@ -1157,7 +1157,7 @@ typedef std::multiset<XMonitor*, SortBottomToTop> PushTopSet;
 
 class TopVariant {
 public:
-    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    static void get_area_in_front(const SpiceRect& base, int size, SpiceRect& area)
     {
         area.left = base.left;
         area.right = base.right;
@@ -1165,55 +1165,55 @@ public:
         area.top = area.bottom - size;
     }
 
-    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    static int get_push_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return other.bottom - fix_area.top;
     }
 
-    static int get_head(const Rect& area)
+    static int get_head(const SpiceRect& area)
     {
         return area.top;
     }
 
-    static int get_tail(const Rect& area)
+    static int get_tail(const SpiceRect& area)
     {
         return area.bottom;
     }
 
-    static void move_head(Rect& area, int delta)
+    static void move_head(SpiceRect& area, int delta)
     {
         area.top -= delta;
         ASSERT(area.bottom >= area.top);
     }
 
-    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    static int get_pull_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return other.top - fix_area.bottom;
     }
 
-    static void offset(Rect& area, int delta)
+    static void offset(SpiceRect& area, int delta)
     {
         rect_offset(area, 0, -delta);
     }
 
-    static void shrink(Rect& area, int delta)
+    static void shrink(SpiceRect& area, int delta)
     {
         area.bottom -= delta;
         ASSERT(area.bottom > area.top);
     }
 
-    static int get_distance(const Rect& area, const Rect& other_area)
+    static int get_distance(const SpiceRect& area, const SpiceRect& other_area)
     {
         return other_area.top - area.top;
     }
 
-    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    static bool is_on_tail(const SpiceRect& area, const SpiceRect& other_area)
     {
         return area.bottom == other_area.top && other_area.left < area.right &&
                other_area.right > area.left;
     }
 
-    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    static bool is_on_perpendiculars(const SpiceRect& area, const SpiceRect& other_area)
     {
         return (other_area.right == area.left || other_area.left == area.right) &&
                other_area.top < area.bottom && other_area.bottom > area.top;
@@ -1233,7 +1233,7 @@ typedef std::multiset<XMonitor*, SortTopToBottom> PushBottomSet;
 class BottomVariant {
 public:
 
-    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    static void get_area_in_front(const SpiceRect& base, int size, SpiceRect& area)
     {
         area.left = base.left;
         area.right = base.right;
@@ -1241,44 +1241,44 @@ public:
         area.bottom = area.top + size;
     }
 
-    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    static int get_push_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return fix_area.bottom - other.top;
     }
 
-    static int get_head(const Rect& area)
+    static int get_head(const SpiceRect& area)
     {
         return area.bottom;
     }
 
-    static int get_tail(const Rect& area)
+    static int get_tail(const SpiceRect& area)
     {
         return area.top;
     }
 
-    static void move_head(Rect& area, int delta)
+    static void move_head(SpiceRect& area, int delta)
     {
         area.bottom += delta;
         ASSERT(area.bottom >= area.top);
     }
 
-    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    static int get_pull_distance(const SpiceRect& fix_area, const SpiceRect& other)
     {
         return fix_area.top - other.bottom;
     }
 
-    static void offset(Rect& area, int delta)
+    static void offset(SpiceRect& area, int delta)
     {
         rect_offset(area, 0, delta);
     }
 
-    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    static bool is_on_tail(const SpiceRect& area, const SpiceRect& other_area)
     {
         return other_area.bottom == area.top && other_area.left < area.right &&
                other_area.right > area.left;
     }
 
-    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    static bool is_on_perpendiculars(const SpiceRect& area, const SpiceRect& other_area)
     {
         return (other_area.right == area.left || other_area.left == area.right) &&
                other_area.top < area.bottom && other_area.bottom > area.top;
@@ -1294,7 +1294,7 @@ static void bounce_back(XMonitor& monitor, const XMonitorsList& monitors, int he
     while (wait_for_me);
 
     for (XMonitorsList::const_iterator iter = monitors.begin(); iter != monitors.end(); iter++) {
-        Rect& area = (*iter)->get_trans_area();
+        SpiceRect& area = (*iter)->get_trans_area();
         if (Variant::get_tail(area) == head && (*iter)->get_pusher() == &monitor) {
             Variant::offset(area, -distance);
             bounce_back<Variant>(**iter, monitors, Variant::get_head(area) + distance, distance);
@@ -1318,13 +1318,13 @@ static int push(XMonitor& pusher, XMonitor& monitor, const XMonitorsList& monito
         sort.insert(*iter);
     }
 
-    Rect area_to_clear;
+    SpiceRect area_to_clear;
     Variant::get_area_in_front(monitor.get_trans_area(), delta, area_to_clear);
 
     SortListIter sort_iter = sort.begin();
 
     for (; sort_iter != sort.end(); sort_iter++) {
-        const Rect& other_area = (*sort_iter)->get_trans_area();
+        const SpiceRect& other_area = (*sort_iter)->get_trans_area();
 
         if (rect_intersects(area_to_clear, other_area)) {
             int distance = Variant::get_push_distance(area_to_clear, other_area);
@@ -1343,13 +1343,13 @@ static int push(XMonitor& pusher, XMonitor& monitor, const XMonitorsList& monito
     }
     Variant::offset(monitor.get_trans_area(), delta);
 
-    const Rect& area = monitor.get_prev_area();
+    const SpiceRect& area = monitor.get_prev_area();
     for (iter = monitors.begin(); iter != monitors.end(); iter++) {
         if ((*iter)->is_pinned()) {
             continue;
         }
 
-        const Rect& other_area = (*iter)->get_prev_area();
+        const SpiceRect& other_area = (*iter)->get_prev_area();
         if (Variant::is_on_perpendiculars(area, other_area)) {
             int current_distance = Variant::get_pull_distance(monitor.get_trans_area(),
                                                               (*iter)->get_trans_area());
@@ -1371,10 +1371,10 @@ static int push(XMonitor& pusher, XMonitor& monitor, const XMonitorsList& monito
 template <class Variant>
 static void pin(XMonitor& monitor, const XMonitorsList& monitors)
 {
-    const Rect& area = monitor.get_trans_area();
+    const SpiceRect& area = monitor.get_trans_area();
 
     for (XMonitorsList::const_iterator iter = monitors.begin(); iter != monitors.end(); iter++) {
-        const Rect& other_area = (*iter)->get_trans_area();
+        const SpiceRect& other_area = (*iter)->get_trans_area();
         if ((*iter)->is_pinned()) {
             continue;
         }
@@ -1402,10 +1402,10 @@ static void shrink(XMonitor& monitor, const XMonitorsList& monitors, int delta)
         sort.insert(*iter);
     }
 
-    const Rect area = monitor.get_trans_area();
+    const SpiceRect area = monitor.get_trans_area();
     Variant::shrink(monitor.get_trans_area(), delta);
     for (SortListIter sort_iter = sort.begin(); sort_iter != sort.end(); sort_iter++) {
-        const Rect& other_area = (*sort_iter)->get_trans_area();
+        const SpiceRect& other_area = (*sort_iter)->get_trans_area();
         if (Variant::is_on_perpendiculars(area, other_area)) {
             int distance = Variant::get_distance(area, other_area);
             if (distance > 0) {
@@ -1433,11 +1433,11 @@ static void expand(XMonitor& monitor, const XMonitorsList& monitors, int delta)
         sort.insert(*iter);
     }
 
-    Rect area_to_clear;
+    SpiceRect area_to_clear;
     Variant::get_area_in_front(monitor.get_trans_area(), delta, area_to_clear);
 
     for (SortListIter sort_iter = sort.begin(); sort_iter != sort.end(); sort_iter++) {
-        const Rect& other_area = (*sort_iter)->get_trans_area();
+        const SpiceRect& other_area = (*sort_iter)->get_trans_area();
 
         if (rect_intersects(area_to_clear, other_area)) {
             int distance = Variant::get_push_distance(area_to_clear, other_area);
@@ -1459,7 +1459,7 @@ bool MultyMonScreen::set_monitor_mode(XMonitor& monitor, const XRRModeInfo& mode
         return false;
     }
 
-    Point size = monitor.get_size();
+    SpicePoint size = monitor.get_size();
     int dx = mode_info.width - size.x;
     int dy = mode_info.height - size.y;
 
@@ -1790,12 +1790,12 @@ int XMonitor::get_depth()
     return XPlatform::get_vinfo()[0]->depth;
 }
 
-Point XMonitor::get_position()
+SpicePoint XMonitor::get_position()
 {
     return _position;
 }
 
-Point XMonitor::get_size() const
+SpicePoint XMonitor::get_size() const
 {
     return _size;
 }
@@ -1810,12 +1810,12 @@ void XMonitor::add_clone(XMonitor *clone)
     _clones.push_back(clone);
 }
 
-const Rect& XMonitor::get_prev_area()
+const SpiceRect& XMonitor::get_prev_area()
 {
     return _trans_area[_trans_depth - 1];
 }
 
-Rect& XMonitor::get_trans_area()
+SpiceRect& XMonitor::get_trans_area()
 {
     return _trans_area[_trans_depth];
 }
@@ -2357,8 +2357,8 @@ void Platform::reset_cursor_pos()
     if (!primary_monitor) {
         return;
     }
-    Point pos =  primary_monitor->get_position();
-    Point size =  primary_monitor->get_size();
+    SpicePoint pos =  primary_monitor->get_position();
+    SpicePoint size =  primary_monitor->get_size();
     Window root_window = RootWindow(x_display, DefaultScreen(x_display));
     XWarpPointer(x_display, None, root_window, 0, 0, 0, 0, pos.x + size.x / 2, pos.y + size.y / 2);
 }
@@ -2434,7 +2434,7 @@ static inline uint32_t get_pix_hack(int pix_index, int width)
 
 XLocalCursor::XLocalCursor(CursorData* cursor_data)
 {
-    const CursorHeader& header = cursor_data->header();
+    const SpiceCursorHeader& header = cursor_data->header();
     const uint8_t* data = cursor_data->data();
     int cur_size = header.width * header.height;
     uint8_t pix_mask;
@@ -2449,9 +2449,9 @@ XLocalCursor::XLocalCursor(CursorData* cursor_data)
     uint32_t* cur_data = new uint32_t[cur_size];
 
     switch (header.type) {
-    case CURSOR_TYPE_ALPHA:
+    case SPICE_CURSOR_TYPE_ALPHA:
         break;
-    case CURSOR_TYPE_COLOR32:
+    case SPICE_CURSOR_TYPE_COLOR32:
         memcpy(cur_data, data, cur_size * sizeof(uint32_t));
         for (i = 0; i < cur_size; i++) {
             pix_mask = get_pix_mask(data, size, i);
@@ -2462,7 +2462,7 @@ XLocalCursor::XLocalCursor(CursorData* cursor_data)
             }
         }
         break;
-    case CURSOR_TYPE_COLOR16:
+    case SPICE_CURSOR_TYPE_COLOR16:
         for (i = 0; i < cur_size; i++) {
             pix_mask = get_pix_mask(data, size, i);
             pix = *((uint16_t*)data + i);
@@ -2474,7 +2474,7 @@ XLocalCursor::XLocalCursor(CursorData* cursor_data)
             }
         }
         break;
-    case CURSOR_TYPE_MONO:
+    case SPICE_CURSOR_TYPE_MONO:
         for (i = 0; i < cur_size; i++) {
             pix_mask = get_pix_mask(data, 0, i);
             pix = get_pix_mask(data, size, i);
@@ -2485,7 +2485,7 @@ XLocalCursor::XLocalCursor(CursorData* cursor_data)
             }
         }
         break;
-    case CURSOR_TYPE_COLOR4:
+    case SPICE_CURSOR_TYPE_COLOR4:
         for (i = 0; i < cur_size; i++) {
             pix_mask = get_pix_mask(data, size + (sizeof(uint32_t) << 4), i);
             int idx = (i & 1) ? (data[i >> 1] & 0x0f) : ((data[i >> 1] & 0xf0) >> 4);
@@ -2497,8 +2497,8 @@ XLocalCursor::XLocalCursor(CursorData* cursor_data)
             }
         }
         break;
-    case CURSOR_TYPE_COLOR24:
-    case CURSOR_TYPE_COLOR8:
+    case SPICE_CURSOR_TYPE_COLOR24:
+    case SPICE_CURSOR_TYPE_COLOR8:
     default:
         LOG_WARN("unsupported cursor type %d", header.type);
         _handle = XCreateFontCursor(x_display, XC_arrow);
@@ -2510,7 +2510,7 @@ XLocalCursor::XLocalCursor(CursorData* cursor_data)
     memset(&image, 0, sizeof(image));
     image.width = header.width;
     image.height = header.height;
-    image.data = (header.type == CURSOR_TYPE_ALPHA ? (char*)data : (char*)cur_data);
+    image.data = (header.type == SPICE_CURSOR_TYPE_ALPHA ? (char*)data : (char*)cur_data);
     image.byte_order = LSBFirst;
     image.bitmap_unit = 32;
     image.bitmap_bit_order = LSBFirst;
diff --git a/client/x11/red_drawable.cpp b/client/x11/red_drawable.cpp
index 4436152b..7485c94d 100644
--- a/client/x11/red_drawable.cpp
+++ b/client/x11/red_drawable.cpp
@@ -28,8 +28,8 @@
 #include <GL/glext.h>
 
 static inline void copy_to_gldrawable_from_gltexture(const RedDrawable_p* dest,
-                                                     const Rect& area,
-                                                     const Point& offset,
+                                                     const SpiceRect& area,
+                                                     const SpicePoint& offset,
                                                      const PixelsSource_p* source,
                                                      int src_x, int src_y)
 {
@@ -90,8 +90,8 @@ static inline void copy_to_gldrawable_from_gltexture(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_gldrawable_from_pixmap(const RedDrawable_p* dest,
-                                                  const Rect& area,
-                                                  const Point& offset,
+                                                  const SpiceRect& area,
+                                                  const SpicePoint& offset,
                                                   const PixelsSource_p* source,
                                                   int src_x, int src_y)
 {
@@ -134,8 +134,8 @@ static inline void copy_to_gldrawable_from_pixmap(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_drawable_from_drawable(const RedDrawable_p* dest,
-                                                  const Rect& area,
-                                                  const Point& offset,
+                                                  const SpiceRect& area,
+                                                  const SpicePoint& offset,
                                                   const PixelsSource_p* source,
                                                   int src_x, int src_y)
 {
@@ -151,8 +151,8 @@ static inline void copy_to_drawable_from_drawable(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_drawable_from_pixmap(const RedDrawable_p* dest,
-                                                const Rect& area,
-                                                const Point& offset,
+                                                const SpiceRect& area,
+                                                const SpicePoint& offset,
                                                 const PixelsSource_p* source,
                                                 int src_x, int src_y)
 {
@@ -167,8 +167,8 @@ static inline void copy_to_drawable_from_pixmap(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_drawable_from_shmdrawable(const RedDrawable_p* dest,
-                                                     const Rect& area,
-                                                     const Point& offset,
+                                                     const SpiceRect& area,
+                                                     const SpicePoint& offset,
                                                      const PixelsSource_p* source,
                                                      int src_x, int src_y)
 {
@@ -184,8 +184,8 @@ static inline void copy_to_drawable_from_shmdrawable(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_x_drawable(const RedDrawable_p* dest,
-                                      const Rect& area,
-                                      const Point& offset,
+                                      const SpiceRect& area,
+                                      const SpicePoint& offset,
                                       const PixelsSource_p* source,
                                       int src_x, int src_y)
 {
@@ -205,8 +205,8 @@ static inline void copy_to_x_drawable(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_gl_drawable(const RedDrawable_p* dest,
-                                       const Rect& area,
-                                       const Point& offset,
+                                       const SpiceRect& area,
+                                       const SpicePoint& offset,
                                        const PixelsSource_p* source,
                                        int src_x, int src_y)
 {
@@ -223,8 +223,8 @@ static inline void copy_to_gl_drawable(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_pixmap_from_drawable(const RedDrawable_p* dest,
-                                                const Rect& area,
-                                                const Point& offset,
+                                                const SpiceRect& area,
+                                                const SpicePoint& offset,
                                                 const PixelsSource_p* source,
                                                 int src_x, int src_y)
 {
@@ -232,8 +232,8 @@ static inline void copy_to_pixmap_from_drawable(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_pixmap_from_shmdrawable(const RedDrawable_p* dest,
-                                                   const Rect& area,
-                                                   const Point& offset,
+                                                   const SpiceRect& area,
+                                                   const SpicePoint& offset,
                                                    const PixelsSource_p* source,
                                                    int src_x, int src_y)
 {
@@ -252,8 +252,8 @@ static inline void copy_to_pixmap_from_shmdrawable(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_pixmap_from_pixmap(const RedDrawable_p* dest,
-                                              const Rect& area,
-                                              const Point& offset,
+                                              const SpiceRect& area,
+                                              const SpicePoint& offset,
                                               const PixelsSource_p* source,
                                               int src_x, int src_y)
 {
@@ -272,8 +272,8 @@ static inline void copy_to_pixmap_from_pixmap(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_pixmap_from_gltexture(const RedDrawable_p* dest,
-                                                 const Rect& area,
-                                                 const Point& offset,
+                                                 const SpiceRect& area,
+                                                 const SpicePoint& offset,
                                                  const PixelsSource_p* source,
                                                  int src_x, int src_y)
 {
@@ -316,8 +316,8 @@ static inline void copy_to_pixmap_from_gltexture(const RedDrawable_p* dest,
 }
 
 static inline void copy_to_pixmap(const RedDrawable_p* dest,
-                                  const Rect& area,
-                                  const Point& offset,
+                                  const SpiceRect& area,
+                                  const SpicePoint& offset,
                                   const PixelsSource_p* source,
                                   int src_x, int src_y)
 {
@@ -339,7 +339,7 @@ static inline void copy_to_pixmap(const RedDrawable_p* dest,
     }
 }
 
-void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& area)
+void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& area)
 {
     PixelsSource_p* source = (PixelsSource_p*)src.get_opaque();
     RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
@@ -361,8 +361,8 @@ void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, con
 }
 
 static inline void blend_to_drawable(const RedDrawable_p* dest,
-                                     const Rect& area,
-                                     const Point& offset,
+                                     const SpiceRect& area,
+                                     const SpicePoint& offset,
                                      const PixelsSource_p* source,
                                      int src_x, int src_y)
 {
@@ -370,8 +370,8 @@ static inline void blend_to_drawable(const RedDrawable_p* dest,
 }
 
 static inline void blend_to_pixmap_from_drawable(const RedDrawable_p* dest,
-                                                 const Rect& area,
-                                                 const Point& offset,
+                                                 const SpiceRect& area,
+                                                 const SpicePoint& offset,
                                                  const PixelsSource_p* source,
                                                  int src_x, int src_y)
 {
@@ -379,8 +379,8 @@ static inline void blend_to_pixmap_from_drawable(const RedDrawable_p* dest,
 }
 
 static inline void blend_to_pixmap_from_pixmap(const RedDrawable_p* dest,
-                                               const Rect& area,
-                                               const Point& offset,
+                                               const SpiceRect& area,
+                                               const SpicePoint& offset,
                                                const PixelsSource_p* source,
                                                int src_x, int src_y)
 {
@@ -399,8 +399,8 @@ static inline void blend_to_pixmap_from_pixmap(const RedDrawable_p* dest,
 }
 
 static inline void blend_to_pixmap(const RedDrawable_p* dest,
-                                   const Rect& area,
-                                   const Point& offset,
+                                   const SpiceRect& area,
+                                   const SpicePoint& offset,
                                    const PixelsSource_p* source,
                                    int src_x, int src_y)
 {
@@ -416,7 +416,7 @@ static inline void blend_to_pixmap(const RedDrawable_p* dest,
     }
 }
 
-void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& area)
+void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& area)
 {
     PixelsSource_p* source = (PixelsSource_p*)src.get_opaque();
     RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
@@ -434,8 +434,8 @@ void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, co
 }
 
 static inline void combine_to_drawable(const RedDrawable_p* dest,
-                                       const Rect& area,
-                                       const Point& offset,
+                                       const SpiceRect& area,
+                                       const SpicePoint& offset,
                                        const PixelsSource_p* source,
                                        int src_x, int src_y,
                                        RedDrawable::CombineOP op)
@@ -444,8 +444,8 @@ static inline void combine_to_drawable(const RedDrawable_p* dest,
 }
 
 static inline void combine_to_pixmap_from_drawable(const RedDrawable_p* dest,
-                                                   const Rect& area,
-                                                   const Point& offset,
+                                                   const SpiceRect& area,
+                                                   const SpicePoint& offset,
                                                    const PixelsSource_p* source,
                                                    int src_x, int src_y,
                                                    RedDrawable::CombineOP op)
@@ -454,8 +454,8 @@ static inline void combine_to_pixmap_from_drawable(const RedDrawable_p* dest,
 }
 
 static inline void combine_to_pixmap_from_pixmap(const RedDrawable_p* dest,
-                                                 const Rect& area,
-                                                 const Point& offset,
+                                                 const SpiceRect& area,
+                                                 const SpicePoint& offset,
                                                  const PixelsSource_p* source,
                                                  int src_x, int src_y,
                                                  RedDrawable::CombineOP op)
@@ -499,8 +499,8 @@ static inline void combine_to_pixmap_from_pixmap(const RedDrawable_p* dest,
 }
 
 static inline void combine_to_pixmap(const RedDrawable_p* dest,
-                                     const Rect& area,
-                                     const Point& offset,
+                                     const SpiceRect& area,
+                                     const SpicePoint& offset,
                                      const PixelsSource_p* source,
                                      int src_x, int src_y,
                                      RedDrawable::CombineOP op)
@@ -517,7 +517,7 @@ static inline void combine_to_pixmap(const RedDrawable_p* dest,
     }
 }
 
-void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& area,
+void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y, const SpiceRect& area,
                                  CombineOP op)
 {
     PixelsSource_p* source = (PixelsSource_p*)src.get_opaque();
@@ -536,13 +536,13 @@ void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y,
     }
 }
 
-void RedDrawable::erase_rect(const Rect& area, rgb32_t color)
+void RedDrawable::erase_rect(const SpiceRect& area, rgb32_t color)
 {
     LOG_WARN("not implemented");
 }
 
-static inline void fill_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t color,
-                                 const Point& offset)
+static inline void fill_drawable(RedDrawable_p* dest, const SpiceRect& area, rgb32_t color,
+                                 const SpicePoint& offset)
 {
     Drawable drawable = dest->source.x_drawable.drawable;
     GC gc = dest->source.x_drawable.gc;
@@ -569,8 +569,8 @@ static inline void fill_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t
                    area.right - area.left, area.bottom - area.top);
 }
 
-static inline void fill_gl_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t color,
-                                    const Point& offset)
+static inline void fill_gl_drawable(RedDrawable_p* dest, const SpiceRect& area, rgb32_t color,
+                                    const SpicePoint& offset)
 {
     int vertex_x1, vertex_x2;
     int vertex_y1, vertex_y2;
@@ -603,8 +603,8 @@ static inline void fill_gl_drawable(RedDrawable_p* dest, const Rect& area, rgb32
     glColor3f(1, 1, 1);
 }
 
-static inline void fill_pixmap(RedDrawable_p* dest, const Rect& area, rgb32_t color,
-                               const Point& offset)
+static inline void fill_pixmap(RedDrawable_p* dest, const SpiceRect& area, rgb32_t color,
+                               const SpicePoint& offset)
 {
     cairo_t* cairo = dest->cairo;
 
@@ -619,7 +619,7 @@ static inline void fill_pixmap(RedDrawable_p* dest, const Rect& area, rgb32_t co
     cairo_fill(cairo);
 }
 
-void RedDrawable::fill_rect(const Rect& area, rgb32_t color)
+void RedDrawable::fill_rect(const SpiceRect& area, rgb32_t color)
 {
     RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
     switch (dest->source.type) {
@@ -637,8 +637,8 @@ void RedDrawable::fill_rect(const Rect& area, rgb32_t color)
     }
 }
 
-static inline void frame_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t color,
-                                  const Point& offset)
+static inline void frame_drawable(RedDrawable_p* dest, const SpiceRect& area, rgb32_t color,
+                                  const SpicePoint& offset)
 {
     Drawable drawable = dest->source.x_drawable.drawable;
     GC gc = dest->source.x_drawable.gc;
@@ -665,8 +665,8 @@ static inline void frame_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t
                    area.right - area.left, area.bottom - area.top);
 }
 
-static inline void frame_pixmap(RedDrawable_p* dest, const Rect& area, rgb32_t color,
-                                const Point& offset)
+static inline void frame_pixmap(RedDrawable_p* dest, const SpiceRect& area, rgb32_t color,
+                                const SpicePoint& offset)
 {
     cairo_t* cairo = dest->cairo;
 
@@ -682,7 +682,7 @@ static inline void frame_pixmap(RedDrawable_p* dest, const Rect& area, rgb32_t c
     cairo_stroke(cairo);
 }
 
-void RedDrawable::frame_rect(const Rect& area, rgb32_t color)
+void RedDrawable::frame_rect(const SpiceRect& area, rgb32_t color)
 {
     RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
     switch (dest->source.type) {
diff --git a/client/x11/red_pixmap_gl.cpp b/client/x11/red_pixmap_gl.cpp
index 886bb0b3..3ed5f73c 100644
--- a/client/x11/red_pixmap_gl.cpp
+++ b/client/x11/red_pixmap_gl.cpp
@@ -173,7 +173,7 @@ void RedPixmapGL::touch_context()
     GLC_ERROR_TEST_FLUSH;
 }
 
-void RedPixmapGL::update_texture(const Rect *bbox)
+void RedPixmapGL::update_texture(const SpiceRect *bbox)
 {
     RenderType rendertype;
     GLuint tex;
diff --git a/client/x11/red_window.cpp b/client/x11/red_window.cpp
index 795a7bbd..14394982 100644
--- a/client/x11/red_window.cpp
+++ b/client/x11/red_window.cpp
@@ -672,37 +672,37 @@ static inline RedKey to_red_key_code(unsigned int keycode)
 
 static inline int to_red_buttons_state(unsigned int state)
 {
-    return ((state & Button1Mask) ? REDC_LBUTTON_MASK : 0) |
-           ((state & Button2Mask) ? REDC_MBUTTON_MASK : 0) |
-           ((state & Button3Mask) ? REDC_RBUTTON_MASK : 0);
+    return ((state & Button1Mask) ? SPICE_MOUSE_BUTTON_MASK_LEFT : 0) |
+           ((state & Button2Mask) ? SPICE_MOUSE_BUTTON_MASK_MIDDLE : 0) |
+           ((state & Button3Mask) ? SPICE_MOUSE_BUTTON_MASK_RIGHT : 0);
 }
 
-static inline RedButton to_red_button(unsigned int botton, unsigned int& state, bool press)
+static inline SpiceMouseButton to_red_button(unsigned int botton, unsigned int& state, bool press)
 {
     unsigned int mask = 0;
-    RedButton ret;
+    SpiceMouseButton ret;
 
     switch (botton) {
     case Button1:
-        mask = REDC_LBUTTON_MASK;
-        ret = REDC_MOUSE_LBUTTON;
+        mask = SPICE_MOUSE_BUTTON_MASK_LEFT;
+        ret = SPICE_MOUSE_BUTTON_LEFT;
         break;
     case Button2:
-        mask = REDC_MBUTTON_MASK;
-        ret = REDC_MOUSE_MBUTTON;
+        mask = SPICE_MOUSE_BUTTON_MASK_MIDDLE;
+        ret = SPICE_MOUSE_BUTTON_MIDDLE;
         break;
     case Button3:
-        mask = REDC_RBUTTON_MASK;
-        ret = REDC_MOUSE_RBUTTON;
+        mask = SPICE_MOUSE_BUTTON_MASK_RIGHT;
+        ret = SPICE_MOUSE_BUTTON_RIGHT;
         break;
     case Button4:
-        ret = REDC_MOUSE_UBUTTON;
+        ret = SPICE_MOUSE_BUTTON_UP;
         break;
     case Button5:
-        ret = REDC_MOUSE_DBUTTON;
+        ret = SPICE_MOUSE_BUTTON_DOWN;
         break;
     default:
-        ret = REDC_MOUSE_INVALID_BUTTON;
+        ret = SPICE_MOUSE_BUTTON_INVALID;
     }
     if (press) {
         state |= mask;
@@ -766,10 +766,10 @@ void RedWindow_p::win_proc(XEvent& event)
     red_window = (RedWindow*)window_pointer;
     switch (event.type) {
     case MotionNotify: {
-        Point size = red_window->get_size();
+        SpicePoint size = red_window->get_size();
         if (event.xmotion.x >= 0 && event.xmotion.y >= 0 &&
             event.xmotion.x < size.x && event.xmotion.y < size.y) {
-            Point origin = red_window->get_origin();
+            SpicePoint origin = red_window->get_origin();
             red_window->get_listener().on_pointer_motion(event.xmotion.x - origin.x,
                                                          event.xmotion.y - origin.y,
                                                          to_red_buttons_state(event.xmotion.state));
@@ -797,8 +797,8 @@ void RedWindow_p::win_proc(XEvent& event)
     }
     case ButtonPress: {
         unsigned int state = to_red_buttons_state(event.xbutton.state);
-        RedButton button = to_red_button(event.xbutton.button, state, true);
-        if (button == REDC_MOUSE_INVALID_BUTTON) {
+        SpiceMouseButton button = to_red_button(event.xbutton.button, state, true);
+        if (button == SPICE_MOUSE_BUTTON_INVALID) {
             DBG(0, "ButtonPress: invalid button %u", event.xbutton.button);
             break;
         }
@@ -807,8 +807,8 @@ void RedWindow_p::win_proc(XEvent& event)
     }
     case ButtonRelease: {
         unsigned int state = to_red_buttons_state(event.xbutton.state);
-        RedButton button = to_red_button(event.xbutton.button, state, false);
-        if (button == REDC_MOUSE_INVALID_BUTTON) {
+        SpiceMouseButton button = to_red_button(event.xbutton.button, state, false);
+        if (button == SPICE_MOUSE_BUTTON_INVALID) {
             DBG(0, "ButtonRelease: invalid button %u", event.xbutton.button);
             break;
         }
@@ -816,8 +816,8 @@ void RedWindow_p::win_proc(XEvent& event)
         break;
     }
     case Expose: {
-        Point origin;
-        Rect area;
+        SpicePoint origin;
+        SpiceRect area;
 
         origin = red_window->get_origin();
         area.left = event.xexpose.x - origin.x;
@@ -887,7 +887,7 @@ void RedWindow_p::win_proc(XEvent& event)
         break;
     case EnterNotify:
         if (!red_window->_ignore_pointer) {
-            Point origin = red_window->get_origin();
+            SpicePoint origin = red_window->get_origin();
             red_window->on_pointer_enter(event.xcrossing.x - origin.x, event.xcrossing.y - origin.y,
                                          to_red_buttons_state(event.xcrossing.state));
         } else {
@@ -1560,7 +1560,7 @@ void RedWindow::minimize()
     sync();
 }
 
-static bool __get_position(Window window, Point& pos)
+static bool __get_position(Window window, SpicePoint& pos)
 {
     pos.x = pos.y = 0;
     for (;;) {
@@ -1592,9 +1592,9 @@ static bool __get_position(Window window, Point& pos)
     return true;
 }
 
-Point RedWindow::get_position()
+SpicePoint RedWindow::get_position()
 {
-    Point pos;
+    SpicePoint pos;
 
     AutoXErrorHandler auto_error_handler;
     int get_position_retries = GET_POSITION_RETRIES;
@@ -1719,17 +1719,17 @@ void RedWindow::set_mouse_position(int x, int y)
     XWarpPointer(x_display, None, _win, 0, 0, 0, 0, x + get_origin().x, y + get_origin().y);
 }
 
-Point RedWindow::get_size()
+SpicePoint RedWindow::get_size()
 {
     XWindowAttributes attrib;
     XGetWindowAttributes(x_display, _win, &attrib);
-    Point size;
+    SpicePoint size;
     size.x = attrib.width;
     size.y = attrib.height;
     return size;
 }
 
-static void window_area_from_attributes(Rect& area, XWindowAttributes& attrib)
+static void window_area_from_attributes(SpiceRect& area, XWindowAttributes& attrib)
 {
     area.left = attrib.x;
     area.right = area.left + attrib.width;
@@ -1760,7 +1760,7 @@ static QRegion *get_visibale_region(Window window)
         return region;
     }
 
-    Rect window_area;
+    SpiceRect window_area;
     window_area_from_attributes(window_area, attrib);
     window_area.right -= window_area.left;
     window_area.bottom -= window_area.top;
@@ -1830,7 +1830,7 @@ public:
     Region_p(QRegion* region) : _region (region) {}
     ~Region_p() { delete _region;}
 
-    void get_bbox(Rect& bbox) const
+    void get_bbox(SpiceRect& bbox) const
     {
         if (region_is_empty(_region)) {
             bbox.left = bbox.right = bbox.top = bbox.bottom = 0;
@@ -1848,7 +1848,7 @@ private:
     QRegion* _region;
 };
 
-bool RedWindow::get_mouse_anchor_point(Point& pt)
+bool RedWindow::get_mouse_anchor_point(SpicePoint& pt)
 {
     QRegion* vis_region;
     int vis_region_retries = GET_VIS_REGION_RETRIES;
@@ -1869,7 +1869,7 @@ bool RedWindow::get_mouse_anchor_point(Point& pt)
     if (!find_anchor_point(region, pt)) {
         return false;
     }
-    Point position = get_position();
+    SpicePoint position = get_position();
     pt.x -= (position.x + get_origin().x);
     pt.y -= (position.y + get_origin().y);
     return true;
diff --git a/client/x11/red_window_p.h b/client/x11/red_window_p.h
index df306344..e630b618 100644
--- a/client/x11/red_window_p.h
+++ b/client/x11/red_window_p.h
@@ -58,7 +58,7 @@ protected:
     Cursor _invisible_cursor;
     bool _visibale;
     bool _expect_parent;
-    Point _show_pos;
+    SpicePoint _show_pos;
     GLXContext _glcont_copy;
     Icon* _icon;
     bool _focused;
diff --git a/common/cairo_canvas.c b/common/cairo_canvas.c
index e8f177bb..1a4993da 100644
--- a/common/cairo_canvas.c
+++ b/common/cairo_canvas.c
@@ -35,26 +35,26 @@ static void canvas_set_path(CairoCanvas *canvas, void *addr)
     access_test(&canvas->base, data_size, sizeof(uint32_t));
     uint32_t more = *data_size;
 
-    PathSeg* seg = (PathSeg*)(data_size + 1);
+    SpicePathSeg* seg = (SpicePathSeg*)(data_size + 1);
 
     do {
-        access_test(&canvas->base, seg, sizeof(PathSeg));
+        access_test(&canvas->base, seg, sizeof(SpicePathSeg));
 
         uint32_t flags = seg->flags;
-        PointFix* point = (PointFix*)seg->data;
-        PointFix* end_point = point + seg->count;
+        SpicePointFix* point = (SpicePointFix*)seg->data;
+        SpicePointFix* end_point = point + seg->count;
         access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
         ASSERT(point < end_point);
         more -= ((unsigned long)end_point - (unsigned long)seg);
-        seg = (PathSeg*)end_point;
+        seg = (SpicePathSeg*)end_point;
 
-        if (flags & PATH_BEGIN) {
+        if (flags & SPICE_PATH_BEGIN) {
             cairo_new_sub_path(cairo);
             cairo_move_to(cairo, fix_to_double(point->x), fix_to_double(point->y));
             point++;
         }
 
-        if (flags & PATH_BEZIER) {
+        if (flags & SPICE_PATH_BEZIER) {
             ASSERT((point - end_point) % 3 == 0);
             for (; point + 2 < end_point; point += 3) {
                 cairo_curve_to(cairo,
@@ -67,8 +67,8 @@ static void canvas_set_path(CairoCanvas *canvas, void *addr)
                 cairo_line_to(cairo, fix_to_double(point->x), fix_to_double(point->y));
             }
         }
-        if (flags & PATH_END) {
-            if (flags & PATH_CLOSE) {
+        if (flags & SPICE_PATH_END) {
+            if (flags & SPICE_PATH_CLOSE) {
                 cairo_close_path(cairo);
             }
             cairo_new_sub_path(cairo);
@@ -76,19 +76,19 @@ static void canvas_set_path(CairoCanvas *canvas, void *addr)
     } while (more);
 }
 
-static void canvas_clip(CairoCanvas *canvas, Clip *clip)
+static void canvas_clip(CairoCanvas *canvas, SpiceClip *clip)
 {
     cairo_t *cairo = canvas->cairo;
 
     switch (clip->type) {
-    case CLIP_TYPE_NONE:
+    case SPICE_CLIP_TYPE_NONE:
         break;
-    case CLIP_TYPE_RECTS: {
-        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+    case SPICE_CLIP_TYPE_RECTS: {
+        uint32_t *n = (uint32_t *)SPICE_GET_ADDRESS(clip->data);
         access_test(&canvas->base, n, sizeof(uint32_t));
 
-        Rect *now = (Rect *)(n + 1);
-        Rect *end = now + *n;
+        SpiceRect *now = (SpiceRect *)(n + 1);
+        SpiceRect *end = now + *n;
         access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
 
         for (; now < end; now++) {
@@ -98,8 +98,8 @@ static void canvas_clip(CairoCanvas *canvas, Clip *clip)
         cairo_clip(cairo);
         break;
     }
-    case CLIP_TYPE_PATH:
-        canvas_set_path(canvas, GET_ADDRESS(clip->data));
+    case SPICE_CLIP_TYPE_PATH:
+        canvas_set_path(canvas, SPICE_GET_ADDRESS(clip->data));
         cairo_clip(cairo);
         break;
     default:
@@ -110,11 +110,11 @@ static void canvas_clip(CairoCanvas *canvas, Clip *clip)
 static inline cairo_line_cap_t canvas_line_cap_to_cairo(int end_style)
 {
     switch (end_style) {
-    case LINE_CAP_ROUND:
+    case SPICE_LINE_CAP_ROUND:
         return CAIRO_LINE_CAP_ROUND;
-    case LINE_CAP_SQUARE:
+    case SPICE_LINE_CAP_SQUARE:
         return CAIRO_LINE_CAP_SQUARE;
-    case LINE_CAP_BUTT:
+    case SPICE_LINE_CAP_BUTT:
         return CAIRO_LINE_CAP_BUTT;
     default:
         CANVAS_ERROR("bad end style %d", end_style);
@@ -124,18 +124,18 @@ static inline cairo_line_cap_t canvas_line_cap_to_cairo(int end_style)
 static inline cairo_line_join_t canvas_line_join_to_cairo(int join_style)
 {
     switch (join_style) {
-    case LINE_JOIN_ROUND:
+    case SPICE_LINE_JOIN_ROUND:
         return CAIRO_LINE_JOIN_ROUND;
-    case LINE_JOIN_BEVEL:
+    case SPICE_LINE_JOIN_BEVEL:
         return CAIRO_LINE_JOIN_BEVEL;
-    case LINE_JOIN_MITER:
+    case SPICE_LINE_JOIN_MITER:
         return CAIRO_LINE_JOIN_MITER;
     default:
         CANVAS_ERROR("bad join style %d", join_style);
     }
 }
 
-static void canvas_set_line_attr_no_dash(CairoCanvas *canvas, LineAttr *attr)
+static void canvas_set_line_attr_no_dash(CairoCanvas *canvas, SpiceLineAttr *attr)
 {
     cairo_t *cairo = canvas->cairo;
 
@@ -146,9 +146,9 @@ static void canvas_set_line_attr_no_dash(CairoCanvas *canvas, LineAttr *attr)
     cairo_set_dash(cairo, NULL, 0, 0);
 }
 
-static void canvas_set_dash(CairoCanvas *canvas, UINT8 nseg, ADDRESS addr, int start_is_gap)
+static void canvas_set_dash(CairoCanvas *canvas, UINT8 nseg, SPICE_ADDRESS addr, int start_is_gap)
 {
-    FIXED28_4* style = (FIXED28_4*)GET_ADDRESS(addr);
+    SPICE_FIXED28_4* style = (SPICE_FIXED28_4*)SPICE_GET_ADDRESS(addr);
     double offset = 0;
     double *local_style;
     int i;
@@ -222,7 +222,7 @@ static inline void canvas_invers_16bpp(uint8_t *dest, int dest_stride, uint8_t *
 }
 
 static inline void canvas_invers_8bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
-                                      int width, uint8_t *end, Palette *palette)
+                                      int width, uint8_t *end, SpicePalette *palette)
 {
     if (!palette) {
         CANVAS_ERROR("no palette");
@@ -242,7 +242,7 @@ static inline void canvas_invers_8bpp(uint8_t *dest, int dest_stride, uint8_t *s
 
 static inline void canvas_invers_4bpp_be(uint8_t* dest, int dest_stride, uint8_t* src,
                                          int src_stride, int width, uint8_t* end,
-                                         Palette *palette)
+                                         SpicePalette *palette)
 {
     if (!palette) {
         CANVAS_ERROR("no palette");
@@ -267,7 +267,7 @@ static inline void canvas_invers_4bpp_be(uint8_t* dest, int dest_stride, uint8_t
 
 static inline void canvas_invers_1bpp_be(uint8_t* dest, int dest_stride, uint8_t* src,
                                          int src_stride, int width, uint8_t* end,
-                                         Palette *palette)
+                                         SpicePalette *palette)
 {
     uint32_t fore_color;
     uint32_t back_color;
@@ -293,10 +293,10 @@ static inline void canvas_invers_1bpp_be(uint8_t* dest, int dest_stride, uint8_t
     }
 }
 
-static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, Bitmap* bitmap,
-                                                        Palette *palette)
+static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, SpiceBitmap* bitmap,
+                                                        SpicePalette *palette)
 {
-    uint8_t* src = (uint8_t *)GET_ADDRESS(bitmap->data);
+    uint8_t* src = (uint8_t *)SPICE_GET_ADDRESS(bitmap->data);
     int src_stride;
     uint8_t* end;
     uint8_t* dest;
@@ -307,7 +307,7 @@ static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, Bit
     end = src + (bitmap->y * src_stride);
     access_test(&canvas->base, src, bitmap->y * src_stride);
 
-    cairo_surface = cairo_image_surface_create((bitmap->format == BITMAP_FMT_RGBA) ?
+    cairo_surface = cairo_image_surface_create((bitmap->format == SPICE_BITMAP_FMT_RGBA) ?
                                                CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
                                                bitmap->x, bitmap->y);
     if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
@@ -317,29 +317,29 @@ static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, Bit
     dest = cairo_image_surface_get_data(cairo_surface);
     dest_stride = cairo_image_surface_get_stride(cairo_surface);
 
-    if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+    if (!(bitmap->flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
         ASSERT(bitmap->y > 0);
         dest += dest_stride * (bitmap->y - 1);
         dest_stride = -dest_stride;
     }
     switch (bitmap->format) {
-    case BITMAP_FMT_32BIT:
-    case BITMAP_FMT_RGBA:
+    case SPICE_BITMAP_FMT_32BIT:
+    case SPICE_BITMAP_FMT_RGBA:
         canvas_invers_32bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
         break;
-    case BITMAP_FMT_24BIT:
+    case SPICE_BITMAP_FMT_24BIT:
         canvas_invers_24bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
         break;
-    case BITMAP_FMT_16BIT:
+    case SPICE_BITMAP_FMT_16BIT:
         canvas_invers_16bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
         break;
-    case BITMAP_FMT_8BIT:
+    case SPICE_BITMAP_FMT_8BIT:
         canvas_invers_8bpp(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
         break;
-    case BITMAP_FMT_4BIT_BE:
+    case SPICE_BITMAP_FMT_4BIT_BE:
         canvas_invers_4bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
         break;
-    case BITMAP_FMT_1BIT_BE:
+    case SPICE_BITMAP_FMT_1BIT_BE:
         canvas_invers_1bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
         break;
     }
@@ -349,22 +349,22 @@ static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, Bit
 #if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
 
 #ifndef CAIRO_CANVAS_CACHE
-static Palette *canvas_get_palette(CairoCanvas *canvas, Bitmap *bitmap)
+static SpicePalette *canvas_get_palette(CairoCanvas *canvas, SpiceBitmap *bitmap)
 {
-    Palette *local_palette;
-    Palette *palette;
+    SpicePalette *local_palette;
+    SpicePalette *palette;
     int size;
 
     if (!bitmap->palette) {
         return NULL;
     }
 
-    palette = (Palette *)GET_ADDRESS(bitmap->palette);
+    palette = (SpicePalette *)SPICE_GET_ADDRESS(bitmap->palette);
     if (canvas->base.color_shift != 5) {
         return palette;
     }
 
-    size = sizeof(Palette) + (palette->num_ents << 2);
+    size = sizeof(SpicePalette) + (palette->num_ents << 2);
     local_palette = malloc(size);
     memcpy(local_palette, palette, size);
     canvas_localize_palette(&canvas->base, palette);
@@ -372,9 +372,9 @@ static Palette *canvas_get_palette(CairoCanvas *canvas, Bitmap *bitmap)
     return local_palette;
 }
 
-static void free_palette(Bitmap *bitmap, Palette *palette)
+static void free_palette(SpiceBitmap *bitmap, SpicePalette *palette)
 {
-    if (!palette || palette == GET_ADDRESS(bitmap->palette)) {
+    if (!palette || palette == SPICE_GET_ADDRESS(bitmap->palette)) {
         return;
     }
     free(palette);
@@ -382,20 +382,20 @@ static void free_palette(Bitmap *bitmap, Palette *palette)
 
 #endif
 
-static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS addr)
+static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, SPICE_ADDRESS addr)
 {
-    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+    SpiceImageDescriptor *descriptor = (SpiceImageDescriptor *)SPICE_GET_ADDRESS(addr);
     cairo_surface_t *surface;
     cairo_surface_t *invers = NULL;
 
-    access_test(&canvas->base, descriptor, sizeof(ImageDescriptor));
+    access_test(&canvas->base, descriptor, sizeof(SpiceImageDescriptor));
 
-    int cache_me = descriptor->flags & IMAGE_CACHE_ME;
+    int cache_me = descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME;
 
     switch (descriptor->type) {
-    case IMAGE_TYPE_QUIC: {
-        QUICImage *image = (QUICImage *)descriptor;
-        access_test(&canvas->base, descriptor, sizeof(QUICImage));
+    case SPICE_IMAGE_TYPE_QUIC: {
+        SpiceQUICImage *image = (SpiceQUICImage *)descriptor;
+        access_test(&canvas->base, descriptor, sizeof(SpiceQUICImage));
         if (cache_me) {
             surface = canvas_get_quic(&canvas->base, image, 0);
         } else {
@@ -404,8 +404,8 @@ static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS add
         break;
     }
 #ifdef CAIRO_CANVAS_NO_CHUNKS
-    case IMAGE_TYPE_LZ_PLT: {
-        access_test(&canvas->base, descriptor, sizeof(LZ_PLTImage));
+    case SPICE_IMAGE_TYPE_LZ_PLT: {
+        access_test(&canvas->base, descriptor, sizeof(SpiceLZPLTImage));
         LZImage *image = (LZImage *)descriptor;
         if (cache_me) {
             surface = canvas_get_lz(&canvas->base, image, 0);
@@ -414,8 +414,8 @@ static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS add
         }
         break;
     }
-    case IMAGE_TYPE_LZ_RGB: {
-        access_test(&canvas->base, descriptor, sizeof(LZ_RGBImage));
+    case SPICE_IMAGE_TYPE_LZ_RGB: {
+        access_test(&canvas->base, descriptor, sizeof(SpiceLZRGBImage));
         LZImage *image = (LZImage *)descriptor;
         if (cache_me) {
             surface = canvas_get_lz(&canvas->base, image, 0);
@@ -426,19 +426,19 @@ static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS add
     }
 #endif
 #ifdef USE_GLZ
-    case IMAGE_TYPE_GLZ_RGB: {
-        access_test(&canvas->base, descriptor, sizeof(LZ_RGBImage));
+    case SPICE_IMAGE_TYPE_GLZ_RGB: {
+        access_test(&canvas->base, descriptor, sizeof(SpiceLZRGBImage));
         LZImage *image = (LZImage *)descriptor;
         surface = canvas_get_glz(&canvas->base, image);
         break;
     }
 #endif
-    case IMAGE_TYPE_FROM_CACHE:
+    case SPICE_IMAGE_TYPE_FROM_CACHE:
         surface = canvas->base.bits_cache_get(canvas->base.bits_cache_opaque, descriptor->id);
         break;
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)descriptor;
-        access_test(&canvas->base, descriptor, sizeof(BitmapImage));
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)descriptor;
+        access_test(&canvas->base, descriptor, sizeof(SpiceBitmapImage));
         if (cache_me) {
             surface = canvas_get_bits(&canvas->base, &bitmap->bitmap);
         } else {
@@ -448,7 +448,7 @@ static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS add
                                                                      bitmap->bitmap.palette,
                                                                      bitmap->bitmap.flags));
 #else
-            Palette *palette = canvas_get_palette(canvas, &bitmap->bitmap);
+            SpicePalette *palette = canvas_get_palette(canvas, &bitmap->bitmap);
             surface = canvas_bitmap_to_invers_surface(canvas, &bitmap->bitmap, palette);
             free_palette(&bitmap->bitmap, palette);
             return surface;
@@ -471,17 +471,17 @@ static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS add
 
 #else
 
-static cairo_surface_t *canvas_get_invers(CairoCanvas *canvas, Bitmap *bitmap)
+static cairo_surface_t *canvas_get_invers(CairoCanvas *canvas, SpiceBitmap *bitmap)
 {
-    Palette *palette;
+    SpicePalette *palette;
 
     if (!bitmap->palette) {
         return canvas_bitmap_to_invers_surface(canvas, bitmap, NULL);
     }
-    palette = (Palette *)GET_ADDRESS(bitmap->palette);
+    palette = (SpicePalette *)SPICE_GET_ADDRESS(bitmap->palette);
     if (canvas->color_shift == 5) {
-        int size = sizeof(Palette) + (palette->num_ents << 2);
-        Palette *local_palette = malloc(size);
+        int size = sizeof(SpicePalette) + (palette->num_ents << 2);
+        SpicePalette *local_palette = malloc(size);
         cairo_surface_t* surface;
 
         memcpy(local_palette, palette, size);
@@ -494,21 +494,21 @@ static cairo_surface_t *canvas_get_invers(CairoCanvas *canvas, Bitmap *bitmap)
     }
 }
 
-static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS addr)
+static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, SPICE_ADDRESS addr)
 {
-    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+    SpiceImageDescriptor *descriptor = (SpiceImageDescriptor *)SPICE_GET_ADDRESS(addr);
 
-    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+    access_test(canvas, descriptor, sizeof(SpiceImageDescriptor));
 
     switch (descriptor->type) {
-    case IMAGE_TYPE_QUIC: {
-        QUICImage *image = (QUICImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(QUICImage));
+    case SPICE_IMAGE_TYPE_QUIC: {
+        SpiceQUICImage *image = (SpiceQUICImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceQUICImage));
         return canvas_get_quic(canvas, image, 1);
     }
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(BitmapImage));
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceBitmapImage));
         return canvas_get_invers(canvas, &bitmap->bitmap);
     }
     default:
@@ -518,7 +518,7 @@ static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS add
 
 #endif
 
-static cairo_surface_t* canvas_surface_from_self(CairoCanvas *canvas, Point *pos,
+static cairo_surface_t* canvas_surface_from_self(CairoCanvas *canvas, SpicePoint *pos,
                                                  int32_t width, int32_t heigth)
 {
     cairo_surface_t *surface;
@@ -547,10 +547,10 @@ static cairo_surface_t* canvas_surface_from_self(CairoCanvas *canvas, Point *pos
     return surface;
 }
 
-static cairo_pattern_t *canvas_get_brush(CairoCanvas *canvas, Brush *brush, uint32_t invers)
+static cairo_pattern_t *canvas_get_brush(CairoCanvas *canvas, SpiceBrush *brush, uint32_t invers)
 {
     switch (brush->type) {
-    case BRUSH_TYPE_SOLID: {
+    case SPICE_BRUSH_TYPE_SOLID: {
         uint32_t color = (invers) ? ~brush->u.color : brush->u.color;
         double r, g, b;
 
@@ -561,7 +561,7 @@ static cairo_pattern_t *canvas_get_brush(CairoCanvas *canvas, Brush *brush, uint
         r = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
         return cairo_pattern_create_rgb(r, g, b);
     }
-    case BRUSH_TYPE_PATTERN: {
+    case SPICE_BRUSH_TYPE_PATTERN: {
         cairo_surface_t* surface;
         cairo_pattern_t *pattern;
         cairo_matrix_t matrix;
@@ -583,7 +583,7 @@ static cairo_pattern_t *canvas_get_brush(CairoCanvas *canvas, Brush *brush, uint
         cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
         return pattern;
     }
-    case BRUSH_TYPE_NONE:
+    case SPICE_BRUSH_TYPE_NONE:
         return NULL;
     default:
         CANVAS_ERROR("invalid brush type");
@@ -604,13 +604,13 @@ static inline int canvas_set_ropd_operator(cairo_t *cairo, uint16_t rop_decripto
 {
     cairo_operator_t cairo_op;
 
-    if (rop_decriptor & ROPD_OP_PUT) {
+    if (rop_decriptor & SPICE_ROPD_OP_PUT) {
         cairo_op = CAIRO_OPERATOR_RASTER_COPY;
-    } else if (rop_decriptor & ROPD_OP_XOR) {
+    } else if (rop_decriptor & SPICE_ROPD_OP_XOR) {
         cairo_op = CAIRO_OPERATOR_RASTER_XOR;
-    } else if (rop_decriptor & ROPD_OP_OR) {
+    } else if (rop_decriptor & SPICE_ROPD_OP_OR) {
         cairo_op = CAIRO_OPERATOR_RASTER_OR;
-    } else if (rop_decriptor & ROPD_OP_AND) {
+    } else if (rop_decriptor & SPICE_ROPD_OP_AND) {
         cairo_op = CAIRO_OPERATOR_RASTER_AND;
     } else {
         return 0;
@@ -625,16 +625,16 @@ static void canvas_draw_with_pattern(CairoCanvas *canvas, cairo_pattern_t *patte
 {
     cairo_t *cairo = canvas->cairo;
 
-    if (rop_decriptor & ROPD_OP_BLACKNESS) {
+    if (rop_decriptor & SPICE_ROPD_OP_BLACKNESS) {
         cairo_set_source_rgb(cairo, 0, 0, 0);
         draw_method(data);
-    } else if (rop_decriptor & ROPD_OP_WHITENESS) {
+    } else if (rop_decriptor & SPICE_ROPD_OP_WHITENESS) {
         cairo_set_source_rgb(cairo, 1, 1, 1);
         draw_method(data);
-    } else if (rop_decriptor & ROPD_OP_INVERS) {
+    } else if (rop_decriptor & SPICE_ROPD_OP_INVERS) {
         __canvas_draw_invers(canvas, draw_method, data);
     } else {
-        if (rop_decriptor & ROPD_INVERS_DEST) {
+        if (rop_decriptor & SPICE_ROPD_INVERS_DEST) {
             __canvas_draw_invers(canvas, draw_method, data);
         }
 
@@ -644,23 +644,23 @@ static void canvas_draw_with_pattern(CairoCanvas *canvas, cairo_pattern_t *patte
             draw_method(data);
         }
 
-        if (rop_decriptor & ROPD_INVERS_RES) {
+        if (rop_decriptor & SPICE_ROPD_INVERS_RES) {
             __canvas_draw_invers(canvas, draw_method, data);
         }
     }
 }
 
-static inline void canvas_draw(CairoCanvas *canvas, Brush *brush, uint16_t rop_decriptor,
+static inline void canvas_draw(CairoCanvas *canvas, SpiceBrush *brush, uint16_t rop_decriptor,
                                DrawMethod draw_method, void *data)
 {
-    cairo_pattern_t *pattern = canvas_get_brush(canvas, brush, rop_decriptor & ROPD_INVERS_BRUSH);
+    cairo_pattern_t *pattern = canvas_get_brush(canvas, brush, rop_decriptor & SPICE_ROPD_INVERS_BRUSH);
     canvas_draw_with_pattern(canvas, pattern, rop_decriptor, draw_method, data);
     if (pattern) {
         cairo_pattern_destroy(pattern);
     }
 }
 
-static cairo_pattern_t *canvas_get_mask_pattern(CairoCanvas *canvas, QMask *mask, int x, int y)
+static cairo_pattern_t *canvas_get_mask_pattern(CairoCanvas *canvas, SpiceQMask *mask, int x, int y)
 {
     cairo_surface_t *surface;
     cairo_pattern_t *pattern;
@@ -692,7 +692,7 @@ static void __draw_mask(void *data)
     cairo_mask(((DrawMaskData *)data)->cairo, ((DrawMaskData *)data)->mask);
 }
 
-void canvas_draw_fill(CairoCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+void canvas_draw_fill(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
 {
     DrawMaskData draw_data;
     draw_data.cairo = canvas->cairo;
@@ -715,8 +715,8 @@ void canvas_draw_fill(CairoCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
     cairo_restore(draw_data.cairo);
 }
 
-static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, ADDRESS src_bitmap,
-                                                const Rect *src, const Rect *dest, int invers,
+static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, SPICE_ADDRESS src_bitmap,
+                                                const SpiceRect *src, const SpiceRect *dest, int invers,
                                                 int scale_mode)
 {
     cairo_pattern_t *pattern;
@@ -724,7 +724,7 @@ static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, ADDRESS src
     cairo_matrix_t matrix;
 
     ASSERT(src_bitmap);
-    ASSERT(scale_mode == IMAGE_SCALE_INTERPOLATE || scale_mode == IMAGE_SCALE_NEAREST);
+    ASSERT(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE || scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
     if (invers) {
         surface = canvas_get_invers_image(canvas, src_bitmap);
     } else {
@@ -745,7 +745,7 @@ static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, ADDRESS src
         sy = (double)(src->bottom - src->top) / (dest->bottom - dest->top);
 
         cairo_matrix_init_scale(&matrix, sx, sy);
-        cairo_pattern_set_filter(pattern, (scale_mode == IMAGE_SCALE_NEAREST) ?
+        cairo_pattern_set_filter(pattern, (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
                                  CAIRO_FILTER_NEAREST : CAIRO_FILTER_GOOD);
 
         cairo_matrix_translate(&matrix, src->left / sx - dest->left, src->top / sy - dest->top);
@@ -757,7 +757,7 @@ static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, ADDRESS src
     return pattern;
 }
 
-void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+void canvas_draw_copy(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_pattern_t *pattern;
@@ -767,7 +767,7 @@ void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
     canvas_clip(canvas, clip);
 
     pattern = canvas_src_image_to_pat(canvas, copy->src_bitmap, &copy->src_area, bbox,
-                                      copy->rop_decriptor & ROPD_INVERS_SRC, copy->scale_mode);
+                                      copy->rop_decriptor & SPICE_ROPD_INVERS_SRC, copy->scale_mode);
     cairo_set_source(cairo, pattern);
     cairo_pattern_destroy(pattern);
     cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
@@ -787,11 +787,11 @@ void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
 }
 
 #ifdef WIN32
-void canvas_put_image(CairoCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *_src_data,
+void canvas_put_image(CairoCanvas *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)
 #else
-void canvas_put_image(CairoCanvas *canvas, const Rect *dest, const uint8_t *_src_data,
+void canvas_put_image(CairoCanvas *canvas, const SpiceRect *dest, const uint8_t *_src_data,
                       uint32_t src_width, uint32_t src_height, int src_stride,
                       const QRegion *clip)
 #endif
@@ -807,8 +807,8 @@ void canvas_put_image(CairoCanvas *canvas, const Rect *dest, const uint8_t *_src
     cairo_save(cairo);
 
     if (clip) {
-        const Rect *now = clip->rects;
-        const Rect *end = clip->rects + clip->num_rects;
+        const SpiceRect *now = clip->rects;
+        const SpiceRect *end = clip->rects + clip->num_rects;
         for (; now < end; now++) {
             cairo_rectangle(cairo, now->left, now->top, now->right - now->left,
                             now->bottom - now->top);
@@ -927,7 +927,7 @@ static cairo_surface_t *canvas_surf_to_color_maks_invers(cairo_surface_t *surfac
     return mask;
 }
 
-void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transparent* transparent)
+void canvas_draw_transparent(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_pattern_t *pattern;
@@ -946,7 +946,7 @@ void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transp
     canvas_clip(canvas, clip);
 
     pattern = canvas_src_image_to_pat(canvas, transparent->src_bitmap, &transparent->src_area, bbox,
-                                      0, IMAGE_SCALE_NEAREST);
+                                      0, SPICE_IMAGE_SCALE_MODE_NEAREST);
     if (cairo_pattern_get_surface(pattern, &surface) != CAIRO_STATUS_SUCCESS) {
         CANVAS_ERROR("surfase from pattern pattern failed");
     }
@@ -970,7 +970,7 @@ void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transp
     cairo_restore(cairo);
 }
 
-void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+void canvas_draw_alpha_blend(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_pattern_t *pattern;
@@ -985,7 +985,7 @@ void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaB
     canvas_clip(canvas, clip);
 
     pattern = canvas_src_image_to_pat(canvas, alpha_blend->src_bitmap, &alpha_blend->src_area, bbox,
-                                      0, IMAGE_SCALE_INTERPOLATE);
+                                      0, SPICE_IMAGE_SCALE_MODE_INTERPOLATE);
     cairo_set_source(cairo, pattern);
     cairo_pattern_destroy(pattern);
     cairo_set_operator(cairo, CAIRO_OPERATOR_ATOP);
@@ -994,7 +994,7 @@ void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaB
     cairo_restore(cairo);
 }
 
-void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+void canvas_draw_opaque(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
 {
     cairo_pattern_t *pattern;
     DrawMaskData draw_data;
@@ -1005,7 +1005,7 @@ void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opa
     canvas_clip(canvas, clip);
 
     pattern = canvas_src_image_to_pat(canvas, opaque->src_bitmap, &opaque->src_area, bbox,
-                                      opaque->rop_decriptor & ROPD_INVERS_SRC, opaque->scale_mode);
+                                      opaque->rop_decriptor & SPICE_ROPD_INVERS_SRC, opaque->scale_mode);
     cairo_set_source(draw_data.cairo, pattern);
     cairo_pattern_destroy(pattern);
     cairo_set_operator(draw_data.cairo, CAIRO_OPERATOR_RASTER_COPY);
@@ -1031,7 +1031,7 @@ void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opa
     cairo_restore(draw_data.cairo);
 }
 
-void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+void canvas_draw_blend(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
 {
     cairo_pattern_t *pattern;
     DrawMaskData mask_data;
@@ -1042,7 +1042,7 @@ void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend
     canvas_clip(canvas, clip);
 
     pattern = canvas_src_image_to_pat(canvas, blend->src_bitmap, &blend->src_area, bbox,
-                                      blend->rop_decriptor & ROPD_INVERS_SRC, blend->scale_mode);
+                                      blend->rop_decriptor & SPICE_ROPD_INVERS_SRC, blend->scale_mode);
 
     if ((mask_data.mask = canvas_get_mask_pattern(canvas, &blend->mask, bbox->left, bbox->top))) {
         cairo_rectangle(mask_data.cairo,
@@ -1065,8 +1065,8 @@ void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend
     cairo_restore(mask_data.cairo);
 }
 
-static inline void canvas_fill_common(CairoCanvas *canvas, Rect *bbox, Clip *clip,
-                                      QMask *qxl_mask)
+static inline void canvas_fill_common(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip,
+                                      SpiceQMask *qxl_mask)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_pattern_t *mask;
@@ -1088,7 +1088,7 @@ static inline void canvas_fill_common(CairoCanvas *canvas, Rect *bbox, Clip *cli
     }
 }
 
-void canvas_draw_blackness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+void canvas_draw_blackness(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_save(cairo);
@@ -1097,7 +1097,7 @@ void canvas_draw_blackness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blacknes
     cairo_restore(cairo);
 }
 
-void canvas_draw_whiteness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+void canvas_draw_whiteness(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_save(cairo);
@@ -1106,7 +1106,7 @@ void canvas_draw_whiteness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Whitenes
     cairo_restore(cairo);
 }
 
-void canvas_draw_invers(CairoCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+void canvas_draw_invers(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_save(cairo);
@@ -1116,18 +1116,18 @@ void canvas_draw_invers(CairoCanvas *canvas, Rect *bbox, Clip *clip, Invers *inv
     cairo_restore(cairo);
 }
 
-void canvas_draw_rop3(CairoCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+void canvas_draw_rop3(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_pattern_t *mask;
     cairo_surface_t *d;
     cairo_surface_t *s;
-    Point pos;
+    SpicePoint pos;
     int width;
     int heigth;
     double x_pos;
     double y_pos;
-    Point src_pos;
+    SpicePoint src_pos;
 
     cairo_save(cairo);
     canvas_clip(canvas, clip);
@@ -1156,9 +1156,9 @@ void canvas_draw_rop3(CairoCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
         cairo_image_surface_get_height(s) - src_pos.y < heigth) {
         CANVAS_ERROR("bad src bitmap size");
     }
-    if (rop3->brush.type == BRUSH_TYPE_PATTERN) {
+    if (rop3->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
         cairo_surface_t *p = canvas_get_image(&canvas->base, rop3->brush.u.pattern.pat);
-        Point pat_pos;
+        SpicePoint pat_pos;
 
         pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % cairo_image_surface_get_width(p);
         pat_pos.y = (bbox->top - rop3->brush.u.pattern.pos.y) % cairo_image_surface_get_height(p);
@@ -1239,8 +1239,8 @@ static inline void __canvas_copy_bits_right(uint8_t *data, const int stride,
     }
 }
 
-static inline void __canvas_copy_rect_bits(uint8_t *data, const int stride, Rect *dest_rect,
-                                           Point *src_pos)
+static inline void __canvas_copy_rect_bits(uint8_t *data, const int stride, SpiceRect *dest_rect,
+                                           SpicePoint *src_pos)
 {
     if (dest_rect->top > src_pos->y) {
         __canvas_copy_bits_down(data, stride, src_pos->x, src_pos->y,
@@ -1260,11 +1260,11 @@ static inline void __canvas_copy_rect_bits(uint8_t *data, const int stride, Rect
     }
 }
 
-static inline void canvas_copy_fix_clip_area(const Rect *dest,
-                                             const Point *src_pos,
-                                             const Rect *now,
-                                             Point *ret_pos,
-                                             Rect *ret_dest)
+static inline void canvas_copy_fix_clip_area(const SpiceRect *dest,
+                                             const SpicePoint *src_pos,
+                                             const SpiceRect *now,
+                                             SpicePoint *ret_pos,
+                                             SpiceRect *ret_dest)
 {
     *ret_dest = *now;
     rect_sect(ret_dest, dest);
@@ -1272,21 +1272,21 @@ static inline void canvas_copy_fix_clip_area(const Rect *dest,
     ret_pos->y = src_pos->y + (ret_dest->top - dest->top);
 }
 
-static inline void __canvas_copy_region_bits(uint8_t *data, int stride, Rect *dest_rect,
-                                             Point *src_pos, QRegion *region)
+static inline void __canvas_copy_region_bits(uint8_t *data, int stride, SpiceRect *dest_rect,
+                                             SpicePoint *src_pos, QRegion *region)
 {
-    Rect curr_area;
-    Point curr_pos;
-    Rect *now;
-    Rect *end;
+    SpiceRect curr_area;
+    SpicePoint curr_pos;
+    SpiceRect *now;
+    SpiceRect *end;
 
     if (dest_rect->top > src_pos->y) {
         end = region->rects - 1;
         now = end + region->num_rects;
         if (dest_rect->left < src_pos->x) {
             for (; now > end; now--) {
-                Rect *line_end = now;
-                Rect *line_pos;
+                SpiceRect *line_end = now;
+                SpiceRect *line_pos;
 
                 while (now - 1 > end && now->top == now[-1].top) {
                     now--;
@@ -1314,8 +1314,8 @@ static inline void __canvas_copy_region_bits(uint8_t *data, int stride, Rect *de
         end = now + region->num_rects;
         if (dest_rect->left > src_pos->x) {
             for (; now < end; now++) {
-                Rect *line_end = now;
-                Rect *line_pos;
+                SpiceRect *line_end = now;
+                SpiceRect *line_pos;
 
                 while (now + 1 < end && now->top == now[1].top) {
                     now++;
@@ -1353,7 +1353,7 @@ static inline void __canvas_copy_region_bits(uint8_t *data, int stride, Rect *de
 
 #endif
 
-void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+void canvas_copy_bits(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_surface_t *surface;
@@ -1363,20 +1363,20 @@ void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_po
     cairo_save(cairo);
 #ifdef FAST_COPY_BITS
     switch (clip->type) {
-    case CLIP_TYPE_NONE: {
+    case SPICE_CLIP_TYPE_NONE: {
         surface = cairo_get_target(cairo);
         __canvas_copy_rect_bits(cairo_image_surface_get_data(surface),
                                 cairo_image_surface_get_stride(surface),
                                 bbox, src_pos);
         break;
     }
-    case CLIP_TYPE_RECTS: {
+    case SPICE_CLIP_TYPE_RECTS: {
         surface = cairo_get_target(cairo);
-        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+        uint32_t *n = (uint32_t *)SPICE_GET_ADDRESS(clip->data);
         access_test(&canvas->base, n, sizeof(uint32_t));
 
-        Rect *now = (Rect *)(n + 1);
-        Rect *end = now + *n;
+        SpiceRect *now = (SpiceRect *)(n + 1);
+        SpiceRect *end = now + *n;
         access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
         uint8_t *data = cairo_image_surface_get_data(surface);
         int stride = cairo_image_surface_get_stride(surface);
@@ -1410,13 +1410,13 @@ void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_po
     cairo_restore(cairo);
 }
 
-static void canvas_draw_raster_str(CairoCanvas *canvas, String *str, int bpp,
-                                   Brush *brush, uint16_t rop_decriptor)
+static void canvas_draw_raster_str(CairoCanvas *canvas, SpiceString *str, int bpp,
+                                   SpiceBrush *brush, uint16_t rop_decriptor)
 {
     cairo_surface_t *str_mask;
     DrawMaskData draw_data;
     cairo_matrix_t matrix;
-    Point pos;
+    SpicePoint pos;
 
     str_mask = canvas_get_str_mask(&canvas->base, str, bpp, &pos);
     draw_data.cairo = canvas->cairo;
@@ -1433,14 +1433,14 @@ static void canvas_draw_raster_str(CairoCanvas *canvas, String *str, int bpp,
     cairo_surface_destroy(str_mask);
 }
 
-static void canvas_draw_vector_str(CairoCanvas *canvas, String *str, Brush *brush,
+static void canvas_draw_vector_str(CairoCanvas *canvas, SpiceString *str, SpiceBrush *brush,
                                    uint16_t rop_decriptor)
 {
-    VectotGlyph *glyph = (VectotGlyph *)str->data;
+    SpiceVectorGlyph *glyph = (SpiceVectorGlyph *)str->data;
     int i;
 
     for (i = 0; i < str->length; i++) {
-        VectotGlyph *next_glyph = canvas_next_vector_glyph(glyph);
+        SpiceVectorGlyph *next_glyph = canvas_next_vector_glyph(glyph);
         access_test(&canvas->base, glyph, (uint8_t *)next_glyph - (uint8_t *)glyph);
         canvas_set_path(canvas, glyph->data);
         glyph = next_glyph;
@@ -1449,10 +1449,10 @@ static void canvas_draw_vector_str(CairoCanvas *canvas, String *str, Brush *brus
     cairo_new_path(canvas->cairo);
 }
 
-void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+void canvas_draw_text(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
 {
     cairo_t *cairo = canvas->cairo;
-    String *str;
+    SpiceString *str;
 
     cairo_save(cairo);
     canvas_clip(canvas, clip);
@@ -1466,13 +1466,13 @@ void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
                     (DrawMethod)cairo_fill_preserve, cairo);
         cairo_new_path(cairo);
     }
-    str = (String *)GET_ADDRESS(text->str);
+    str = (SpiceString *)SPICE_GET_ADDRESS(text->str);
 
-    if (str->flags & STRING_RASTER_A1) {
+    if (str->flags & SPICE_STRING_FLAGS_RASTER_A1) {
         canvas_draw_raster_str(canvas, str, 1, &text->fore_brush, text->fore_mode);
-    } else if (str->flags & STRING_RASTER_A4) {
+    } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A4) {
         canvas_draw_raster_str(canvas, str, 4, &text->fore_brush, text->fore_mode);
-    } else if (str->flags & STRING_RASTER_A8) {
+    } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
         WARN("untested path A8 glyphs, doing nothing");
         if (0) {
             canvas_draw_raster_str(canvas, str, 8, &text->fore_brush, text->fore_mode);
@@ -1486,7 +1486,7 @@ void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
     cairo_restore(cairo);
 }
 
-void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+void canvas_draw_stroke(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
 {
     cairo_t *cairo = canvas->cairo;
 
@@ -1494,12 +1494,12 @@ void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *str
     canvas_clip(canvas, clip);
 
     canvas_set_line_attr_no_dash(canvas, &stroke->attr);
-    canvas_set_path(canvas, GET_ADDRESS(stroke->path));
-    if (stroke->attr.flags & LINE_ATTR_STYLED) {
+    canvas_set_path(canvas, SPICE_GET_ADDRESS(stroke->path));
+    if (stroke->attr.flags & SPICE_LINE_ATTR_STYLED) {
         canvas_draw(canvas, &stroke->brush, stroke->back_mode,
                     (DrawMethod)cairo_stroke_preserve, cairo);
         canvas_set_dash(canvas, stroke->attr.style_nseg, stroke->attr.style,
-                        !!(stroke->attr.flags & LINE_ATTR_STARTGAP));
+                        !!(stroke->attr.flags & SPICE_LINE_ATTR_STARTGAP));
     }
     canvas_draw(canvas, &stroke->brush, stroke->fore_mode, (DrawMethod)cairo_stroke_preserve,
                 cairo);
@@ -1507,7 +1507,7 @@ void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *str
     cairo_restore(cairo);
 }
 
-void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area)
+void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const SpiceRect *area)
 {
     cairo_t *cairo = canvas->cairo;
     cairo_surface_t* surface;
@@ -1527,14 +1527,14 @@ void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const
     }
 }
 
-void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, Rect *clip_rects)
+void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, SpiceRect *clip_rects)
 {
     cairo_t *cairo = canvas->cairo;
 
     cairo_save(cairo);
 
     if (n_clip_rects) {
-        Rect *end = clip_rects + n_clip_rects;
+        SpiceRect *end = clip_rects + n_clip_rects;
         for (; clip_rects < end; clip_rects++) {
             cairo_rectangle(cairo,
                             clip_rects->left,
diff --git a/common/cairo_canvas.h b/common/cairo_canvas.h
index d144b35d..da4d229e 100644
--- a/common/cairo_canvas.h
+++ b/common/cairo_canvas.h
@@ -27,33 +27,33 @@
 
 typedef struct CairoCanvas CairoCanvas;
 
-void canvas_draw_fill(CairoCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill);
-void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy);
-void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
-void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos);
-void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text);
-void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
-void canvas_draw_rop3(CairoCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
-void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend);
-void canvas_draw_blackness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
-void canvas_draw_whiteness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
-void canvas_draw_invers(CairoCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers);
-void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transparent* transparent);
-void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+void canvas_draw_fill(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+void canvas_draw_copy(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+void canvas_draw_opaque(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+void canvas_copy_bits(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+void canvas_draw_text(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
+void canvas_draw_stroke(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+void canvas_draw_rop3(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+void canvas_draw_blend(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+void canvas_draw_blackness(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+void canvas_draw_whiteness(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+void canvas_draw_invers(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+void canvas_draw_transparent(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
+void canvas_draw_alpha_blend(CairoCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
 #ifdef WIN32
-void canvas_put_image(CairoCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *src_data,
+void canvas_put_image(CairoCanvas *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);
 #else
-void canvas_put_image(CairoCanvas *canvas, const Rect *dest, const uint8_t *src_data,
+void canvas_put_image(CairoCanvas *canvas, const SpiceRect *dest, const uint8_t *src_data,
                       uint32_t src_width, uint32_t src_height, int src_stride,
                       const QRegion *clip);
 #endif
 void canvas_clear(CairoCanvas *canvas);
-void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area);
-void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, Rect *clip_rects);
+void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const SpiceRect *area);
+void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, SpiceRect *clip_rects);
 void canvas_group_end(CairoCanvas *canvas);
-void canvas_set_addr_delta(CairoCanvas *canvas, ADDRESS delta);
+void canvas_set_addr_delta(CairoCanvas *canvas, SPICE_ADDRESS delta);
 #ifdef CAIRO_CANVAS_ACCESS_TEST
 void canvas_set_access_params(CairoCanvas *canvas, unsigned long base, unsigned long max);
 #endif
diff --git a/common/canvas_base.c b/common/canvas_base.c
index 2b8148d7..e4055933 100644
--- a/common/canvas_base.c
+++ b/common/canvas_base.c
@@ -79,10 +79,10 @@ typedef struct  __declspec (align(1)) LZImage {
 #else
 typedef struct __attribute__ ((__packed__)) LZImage {
 #endif
-    ImageDescriptor descriptor;
+    SpiceImageDescriptor descriptor;
     union {
-        LZ_RGBData lz_rgb;
-        LZ_PLTData lz_plt;
+        SpiceLZRGBData lz_rgb;
+        SpiceLZPLTData lz_plt;
     };
 } LZImage;
 
@@ -93,7 +93,7 @@ static const cairo_user_data_key_t invers_data_type = {0};
 extern mutex_t cairo_surface_user_data_mutex;
 #endif
 
-static inline double fix_to_double(FIXED28_4 fixed)
+static inline double fix_to_double(SPICE_FIXED28_4 fixed)
 {
     return (double)(fixed & 0x0f) / 0x0f + (fixed >> 4);
 }
@@ -150,7 +150,7 @@ typedef struct QuicData {
     QuicContext *quic;
     jmp_buf jmp_env;
 #ifndef CAIRO_CANVAS_NO_CHUNKS
-    ADDRESS next;
+    SPICE_ADDRESS next;
     get_virt_fn_t get_virt;
     void *get_virt_opaque;
     validate_virt_fn_t validate_virt;
@@ -200,8 +200,8 @@ typedef struct CanvasBase {
 
 typedef struct ATTR_PACKED DataChunk {
     UINT32 size;
-    ADDRESS prev;
-    ADDRESS next;
+    SPICE_ADDRESS prev;
+    SPICE_ADDRESS next;
     UINT8 data[0];
 } DataChunk;
 
@@ -214,7 +214,7 @@ typedef struct ATTR_PACKED DataChunk {
 #endif
 
 
-static inline void canvas_localize_palette(CanvasBase *canvas, Palette *palette)
+static inline void canvas_localize_palette(CanvasBase *canvas, SpicePalette *palette)
 {
     if (canvas->color_shift == 5) {
         UINT32 *now = palette->ents;
@@ -229,7 +229,7 @@ static inline void canvas_localize_palette(CanvasBase *canvas, Palette *palette)
 #ifdef DEBUG_DUMP_COMPRESS
 static void dump_surface(cairo_surface_t *surface, int cache);
 #endif
-static cairo_surface_t *canvas_get_quic(CanvasBase *canvas, QUICImage *image, int invers)
+static cairo_surface_t *canvas_get_quic(CanvasBase *canvas, SpiceQUICImage *image, int invers)
 {
     cairo_surface_t *surface = NULL;
     QuicData *quic_data = &canvas->quic_data;
@@ -360,7 +360,7 @@ static inline void canvas_copy_16bpp(uint8_t* dest, int dest_stride, uint8_t* sr
 }
 
 static inline void canvas_copy_8bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
-                                    int width, uint8_t *end, Palette *palette)
+                                    int width, uint8_t *end, SpicePalette *palette)
 {
     if (!palette) {
         CANVAS_ERROR("no palette");
@@ -379,7 +379,7 @@ static inline void canvas_copy_8bpp(uint8_t *dest, int dest_stride, uint8_t *src
 }
 
 static inline void canvas_copy_4bpp_be(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
-                                       int width, uint8_t* end, Palette *palette)
+                                       int width, uint8_t* end, SpicePalette *palette)
 {
     if (!palette) {
         CANVAS_ERROR("no palette");
@@ -403,7 +403,7 @@ static inline void canvas_copy_4bpp_be(uint8_t* dest, int dest_stride, uint8_t*
 }
 
 static inline void canvas_copy_1bpp_be(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
-                                       int width, uint8_t* end, Palette *palette)
+                                       int width, uint8_t* end, SpicePalette *palette)
 {
     uint32_t fore_color;
     uint32_t back_color;
@@ -429,10 +429,10 @@ static inline void canvas_copy_1bpp_be(uint8_t* dest, int dest_stride, uint8_t*
     }
 }
 
-static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *canvas, Bitmap* bitmap,
-                                                 Palette *palette)
+static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *canvas, SpiceBitmap* bitmap,
+                                                 SpicePalette *palette)
 {
-    uint8_t* src = (uint8_t *)GET_ADDRESS(bitmap->data);
+    uint8_t* src = (uint8_t *)SPICE_GET_ADDRESS(bitmap->data);
     int src_stride;
     uint8_t* end;
     uint8_t* dest;
@@ -447,7 +447,7 @@ static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *canvas, Bitmap* bit
 #ifdef WIN32
                                    canvas->dc,
 #endif
-                                   (bitmap->format == BITMAP_FMT_RGBA) ? CAIRO_FORMAT_ARGB32 :
+                                   (bitmap->format == SPICE_BITMAP_FMT_RGBA) ? CAIRO_FORMAT_ARGB32 :
                                                                          CAIRO_FORMAT_RGB24,
                                    bitmap->x, bitmap->y, FALSE);
     if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
@@ -456,30 +456,30 @@ static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *canvas, Bitmap* bit
     }
     dest = cairo_image_surface_get_data(cairo_surface);
     dest_stride = cairo_image_surface_get_stride(cairo_surface);
-    if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+    if (!(bitmap->flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
         ASSERT(bitmap->y > 0);
         dest += dest_stride * ((int)bitmap->y - 1);
         dest_stride = -dest_stride;
     }
 
     switch (bitmap->format) {
-    case BITMAP_FMT_32BIT:
-    case BITMAP_FMT_RGBA:
+    case SPICE_BITMAP_FMT_32BIT:
+    case SPICE_BITMAP_FMT_RGBA:
         canvas_copy_32bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
         break;
-    case BITMAP_FMT_24BIT:
+    case SPICE_BITMAP_FMT_24BIT:
         canvas_copy_24bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
         break;
-    case BITMAP_FMT_16BIT:
+    case SPICE_BITMAP_FMT_16BIT:
         canvas_copy_16bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
         break;
-    case BITMAP_FMT_8BIT:
+    case SPICE_BITMAP_FMT_8BIT:
         canvas_copy_8bpp(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
         break;
-    case BITMAP_FMT_4BIT_BE:
+    case SPICE_BITMAP_FMT_4BIT_BE:
         canvas_copy_4bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
         break;
-    case BITMAP_FMT_1BIT_BE:
+    case SPICE_BITMAP_FMT_1BIT_BE:
         canvas_copy_1bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
         break;
     }
@@ -488,23 +488,23 @@ static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *canvas, Bitmap* bit
 
 #ifdef CAIRO_CANVAS_CACHE
 
-static inline Palette *canvas_get_palett(CanvasBase *canvas, ADDRESS base_palette, uint8_t flags)
+static inline SpicePalette *canvas_get_palett(CanvasBase *canvas, SPICE_ADDRESS base_palette, uint8_t flags)
 {
-    Palette *palette;
+    SpicePalette *palette;
     if (!base_palette) {
         return NULL;
     }
 
-    if (flags & BITMAP_PAL_FROM_CACHE) {
+    if (flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE) {
         palette = canvas->palette_cache_get(canvas->palette_cache_opaque, base_palette);
-    } else if (flags & BITMAP_PAL_CACHE_ME) {
-        palette = (Palette *)GET_ADDRESS(base_palette);
-        access_test(canvas, palette, sizeof(Palette));
-        access_test(canvas, palette, sizeof(Palette) + palette->num_ents * sizeof(uint32_t));
+    } else if (flags & SPICE_BITMAP_FLAGS_PAL_CACHE_ME) {
+        palette = (SpicePalette *)SPICE_GET_ADDRESS(base_palette);
+        access_test(canvas, palette, sizeof(SpicePalette));
+        access_test(canvas, palette, sizeof(SpicePalette) + palette->num_ents * sizeof(uint32_t));
         canvas_localize_palette(canvas, palette);
         canvas->palette_cache_put(canvas->palette_cache_opaque, palette);
     } else {
-        palette = (Palette *)GET_ADDRESS(base_palette);
+        palette = (SpicePalette *)SPICE_GET_ADDRESS(base_palette);
         canvas_localize_palette(canvas, palette);
     }
     return palette;
@@ -518,7 +518,7 @@ static cairo_surface_t *canvas_get_lz(CanvasBase *canvas, LZImage *image, int in
     uint8_t    *decomp_buf = NULL;
     uint8_t    *src;
     LzImageType type;
-    Palette *palette;
+    SpicePalette *palette;
     int alpha;
     int n_comp_pixels;
     int width;
@@ -533,11 +533,11 @@ static cairo_surface_t *canvas_get_lz(CanvasBase *canvas, LZImage *image, int in
         CANVAS_ERROR("lz error, %s", lz_data->message_buf);
     }
 
-    if (image->descriptor.type == IMAGE_TYPE_LZ_RGB) {
+    if (image->descriptor.type == SPICE_IMAGE_TYPE_LZ_RGB) {
         comp_buf = image->lz_rgb.data;
         comp_size = image->lz_rgb.data_size;
         palette = NULL;
-    } else if (image->descriptor.type == IMAGE_TYPE_LZ_PLT) {
+    } else if (image->descriptor.type == SPICE_IMAGE_TYPE_LZ_PLT) {
         comp_buf = image->lz_plt.data;
         comp_size = image->lz_plt.data_size;
         palette = canvas_get_palett(canvas, image->lz_plt.palette, image->lz_plt.flags);
@@ -569,7 +569,7 @@ static cairo_surface_t *canvas_get_lz(CanvasBase *canvas, LZImage *image, int in
     ASSERT(width == image->descriptor.width);
     ASSERT(height == image->descriptor.height);
 
-    ASSERT((image->descriptor.type == IMAGE_TYPE_LZ_PLT) || (n_comp_pixels == width * 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
@@ -612,7 +612,7 @@ static cairo_surface_t *canvas_get_lz(CanvasBase *canvas, LZImage *image, int in
 // same byte sequence can be transformed to different RGB pixels by different plts)
 static cairo_surface_t *canvas_get_glz(CanvasBase *canvas, LZImage *image)
 {
-    ASSERT(image->descriptor.type == IMAGE_TYPE_GLZ_RGB);
+    ASSERT(image->descriptor.type == SPICE_IMAGE_TYPE_GLZ_RGB);
 #ifdef WIN32
     canvas->glz_data.decode_data.dc = canvas->dc;
 #endif
@@ -625,9 +625,9 @@ static cairo_surface_t *canvas_get_glz(CanvasBase *canvas, LZImage *image)
 //#define DEBUG_DUMP_BITMAP
 
 #ifdef DEBUG_DUMP_BITMAP
-static void dump_bitmap(Bitmap *bitmap, Palette *palette)
+static void dump_bitmap(SpiceBitmap *bitmap, SpicePalette *palette)
 {
-    uint8_t* data = (uint8_t *)GET_ADDRESS(bitmap->data);
+    uint8_t* data = (uint8_t *)SPICE_GET_ADDRESS(bitmap->data);
     static uint32_t file_id = 0;
     uint32_t i, j;
     char file_str[200];
@@ -662,10 +662,10 @@ static void dump_bitmap(Bitmap *bitmap, Palette *palette)
 
 #endif
 
-static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
+static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, SpiceBitmap *bitmap)
 {
     cairo_surface_t* surface;
-    Palette *palette;
+    SpicePalette *palette;
 
     palette = canvas_get_palett(canvas, bitmap->palette, bitmap->flags);
 #ifdef DEBUG_DUMP_BITMAP
@@ -676,7 +676,7 @@ static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
 
     surface = canvas_bitmap_to_surface(canvas, bitmap, palette);
 
-    if (palette && (bitmap->flags & BITMAP_PAL_FROM_CACHE)) {
+    if (palette && (bitmap->flags & SPICE_BITMAP_FLAGS_PAL_FROM_CACHE)) {
         canvas->palette_cache_release(palette);
     }
 
@@ -686,17 +686,17 @@ static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
 #else
 
 
-static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
+static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, SpiceBitmap *bitmap)
 {
-    Palette *palette;
+    SpicePalette *palette;
 
     if (!bitmap->palette) {
         return canvas_bitmap_to_surface(canvas, bitmap, NULL);
     }
-    palette = (Palette *)GET_ADDRESS(bitmap->palette);
+    palette = (SpicePalette *)SPICE_GET_ADDRESS(bitmap->palette);
     if (canvas->color_shift == 5) {
-        int size = sizeof(Palette) + (palette->num_ents << 2);
-        Palette *local_palette = malloc(size);
+        int size = sizeof(SpicePalette) + (palette->num_ents << 2);
+        SpicePalette *local_palette = malloc(size);
         cairo_surface_t* surface;
 
         memcpy(local_palette, palette, size);
@@ -773,49 +773,49 @@ static void __release_surface(void *inv_surf)
 
 //#define DEBUG_LZ
 
-static cairo_surface_t *canvas_get_image(CanvasBase *canvas, ADDRESS addr)
+static cairo_surface_t *canvas_get_image(CanvasBase *canvas, SPICE_ADDRESS addr)
 {
-    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+    SpiceImageDescriptor *descriptor = (SpiceImageDescriptor *)SPICE_GET_ADDRESS(addr);
     cairo_surface_t *surface;
-    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+    access_test(canvas, descriptor, sizeof(SpiceImageDescriptor));
 #ifdef DEBUG_LZ
     LOG_DEBUG("canvas_get_image image type: " << (int)descriptor->type);
 #endif
 
     switch (descriptor->type) {
-    case IMAGE_TYPE_QUIC: {
-        QUICImage *image = (QUICImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(QUICImage));
+    case SPICE_IMAGE_TYPE_QUIC: {
+        SpiceQUICImage *image = (SpiceQUICImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceQUICImage));
         surface = canvas_get_quic(canvas, image, 0);
         break;
     }
 #ifdef CAIRO_CANVAS_NO_CHUNKS
-    case IMAGE_TYPE_LZ_PLT: {
-        access_test(canvas, descriptor, sizeof(LZ_PLTImage));
+    case SPICE_IMAGE_TYPE_LZ_PLT: {
+        access_test(canvas, descriptor, sizeof(SpiceLZPLTImage));
         LZImage *image = (LZImage *)descriptor;
         surface = canvas_get_lz(canvas, image, 0);
         break;
     }
-    case IMAGE_TYPE_LZ_RGB: {
-        access_test(canvas, descriptor, sizeof(LZ_RGBImage));
+    case SPICE_IMAGE_TYPE_LZ_RGB: {
+        access_test(canvas, descriptor, sizeof(SpiceLZRGBImage));
         LZImage *image = (LZImage *)descriptor;
         surface = canvas_get_lz(canvas, image, 0);
         break;
     }
 #endif
 #ifdef USE_GLZ
-    case IMAGE_TYPE_GLZ_RGB: {
-        access_test(canvas, descriptor, sizeof(LZ_RGBImage));
+    case SPICE_IMAGE_TYPE_GLZ_RGB: {
+        access_test(canvas, descriptor, sizeof(SpiceLZRGBImage));
         LZImage *image = (LZImage *)descriptor;
         surface = canvas_get_glz(canvas, image);
         break;
     }
 #endif
-    case IMAGE_TYPE_FROM_CACHE:
+    case SPICE_IMAGE_TYPE_FROM_CACHE:
         return canvas->bits_cache_get(canvas->bits_cache_opaque, descriptor->id);
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(BitmapImage));
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceBitmapImage));
         surface = canvas_get_bits(canvas, &bitmap->bitmap);
         break;
     }
@@ -823,12 +823,12 @@ static cairo_surface_t *canvas_get_image(CanvasBase *canvas, ADDRESS addr)
         CANVAS_ERROR("invalid image type");
     }
 
-    if (descriptor->flags & IMAGE_CACHE_ME) {
+    if (descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME) {
         canvas->bits_cache_put(canvas->bits_cache_opaque, descriptor->id, surface);
 #ifdef DEBUG_DUMP_SURFACE
         dump_surface(surface, 1);
 #endif
-    } else if (descriptor->type != IMAGE_TYPE_FROM_CACHE) {
+    } else if (descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE) {
 #ifdef DEBUG_DUMP_SURFACE
         dump_surface(surface, 0);
 #endif
@@ -838,21 +838,21 @@ static cairo_surface_t *canvas_get_image(CanvasBase *canvas, ADDRESS addr)
 
 #else
 
-static cairo_surface_t *canvas_get_image(CairoCanvas *canvas, ADDRESS addr)
+static cairo_surface_t *canvas_get_image(CairoCanvas *canvas, SPICE_ADDRESS addr)
 {
-    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+    SpiceImageDescriptor *descriptor = (SpiceImageDescriptor *)SPICE_GET_ADDRESS(addr);
 
-    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+    access_test(canvas, descriptor, sizeof(SpiceImageDescriptor));
 
     switch (descriptor->type) {
-    case IMAGE_TYPE_QUIC: {
-        QUICImage *image = (QUICImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(QUICImage));
+    case SPICE_IMAGE_TYPE_QUIC: {
+        SpiceQUICImage *image = (SpiceQUICImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceQUICImage));
         return canvas_get_quic(canvas, image, 0);
     }
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(BitmapImage));
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceBitmapImage));
         return canvas_get_bits(canvas, &bitmap->bitmap);
     }
     default:
@@ -875,7 +875,7 @@ static inline uint8_t revers_bits(uint8_t byte)
     return ret;
 }
 
-static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitmap, int invers)
+static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, SpiceBitmap* bitmap, int invers)
 {
     cairo_surface_t *surface;
     uint8_t *src_line;
@@ -895,7 +895,7 @@ static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitma
                      cairo_status_to_string(cairo_surface_status(surface)));
     }
 
-    src_line = (uint8_t *)GET_ADDRESS(bitmap->data);
+    src_line = (uint8_t *)SPICE_GET_ADDRESS(bitmap->data);
     src_stride = bitmap->stride;
     end_line = src_line + (bitmap->y * src_stride);
     access_test(canvas, src_line, end_line - src_line);
@@ -904,9 +904,9 @@ static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitma
     dest_stride = cairo_image_surface_get_stride(surface);
     dest_line = cairo_image_surface_get_data(surface);
 #if defined(GL_CANVAS)
-    if ((bitmap->flags & BITMAP_TOP_DOWN)) {
+    if ((bitmap->flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
 #else
-    if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+    if (!(bitmap->flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
 #endif
         ASSERT(bitmap->y > 0);
         dest_line += dest_stride * ((int)bitmap->y - 1);
@@ -916,9 +916,9 @@ static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitma
     if (invers) {
         switch (bitmap->format) {
 #if defined(GL_CANVAS) || defined(GDI_CANVAS)
-        case BITMAP_FMT_1BIT_BE:
+        case SPICE_BITMAP_FMT_1BIT_BE:
 #else
-        case BITMAP_FMT_1BIT_LE:
+        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;
@@ -930,9 +930,9 @@ static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitma
             }
             break;
 #if defined(GL_CANVAS) || defined(GDI_CANVAS)
-        case BITMAP_FMT_1BIT_LE:
+        case SPICE_BITMAP_FMT_1BIT_LE:
 #else
-        case BITMAP_FMT_1BIT_BE:
+        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;
@@ -951,18 +951,18 @@ static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitma
     } else {
         switch (bitmap->format) {
 #if defined(GL_CANVAS) || defined(GDI_CANVAS)
-        case BITMAP_FMT_1BIT_BE:
+        case SPICE_BITMAP_FMT_1BIT_BE:
 #else
-        case BITMAP_FMT_1BIT_LE:
+        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 BITMAP_FMT_1BIT_LE:
+        case SPICE_BITMAP_FMT_1BIT_LE:
 #else
-        case BITMAP_FMT_1BIT_BE:
+        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;
@@ -1092,9 +1092,9 @@ static inline cairo_surface_t* canvas_handle_inverse_user_data(cairo_surface_t*
     return inv_surf;
 }
 
-static cairo_surface_t *canvas_get_mask(CanvasBase *canvas, QMask *mask)
+static cairo_surface_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask)
 {
-    ImageDescriptor *descriptor;
+    SpiceImageDescriptor *descriptor;
     cairo_surface_t *surface;
     int need_invers;
     int is_invers;
@@ -1104,26 +1104,26 @@ static cairo_surface_t *canvas_get_mask(CanvasBase *canvas, QMask *mask)
         return NULL;
     }
 
-    descriptor = (ImageDescriptor *)GET_ADDRESS(mask->bitmap);
-    access_test(canvas, descriptor, sizeof(ImageDescriptor));
-    need_invers = mask->flags & MASK_INVERS;
+    descriptor = (SpiceImageDescriptor *)SPICE_GET_ADDRESS(mask->bitmap);
+    access_test(canvas, descriptor, sizeof(SpiceImageDescriptor));
+    need_invers = mask->flags & SPICE_MASK_FLAGS_INVERS;
 
 #ifdef CAIRO_CANVAS_CACHE
-    cache_me = descriptor->flags & IMAGE_CACHE_ME;
+    cache_me = descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_ME;
 #else
     cache_me = 0;
 #endif
 
     switch (descriptor->type) {
-    case IMAGE_TYPE_BITMAP: {
-        BitmapImage *bitmap = (BitmapImage *)descriptor;
-        access_test(canvas, descriptor, sizeof(BitmapImage));
+    case SPICE_IMAGE_TYPE_BITMAP: {
+        SpiceBitmapImage *bitmap = (SpiceBitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(SpiceBitmapImage));
         is_invers = need_invers && !cache_me;
         surface = canvas_get_bitmap_mask(canvas, &bitmap->bitmap, is_invers);
         break;
     }
 #if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
-    case IMAGE_TYPE_FROM_CACHE:
+    case SPICE_IMAGE_TYPE_FROM_CACHE:
         surface = canvas->bits_cache_get(canvas->bits_cache_opaque, descriptor->id);
         is_invers = 0;
         break;
@@ -1149,13 +1149,13 @@ static cairo_surface_t *canvas_get_mask(CanvasBase *canvas, QMask *mask)
     return surface;
 }
 
-static inline RasterGlyph *canvas_next_raster_glyph(const RasterGlyph *glyph, int bpp)
+static inline SpiceRasterGlyph *canvas_next_raster_glyph(const SpiceRasterGlyph *glyph, int bpp)
 {
-    return (RasterGlyph *)((uint8_t *)(glyph + 1) +
+    return (SpiceRasterGlyph *)((uint8_t *)(glyph + 1) +
                                           (ALIGN(glyph->width * bpp, 8) * glyph->height >> 3));
 }
 
-static inline void canvas_raster_glyph_box(const RasterGlyph *glyph, Rect *r)
+static inline void canvas_raster_glyph_box(const SpiceRasterGlyph *glyph, SpiceRect *r)
 {
     ASSERT(r);
     r->top = glyph->render_pos.y + glyph->glyph_origin.y;
@@ -1222,15 +1222,15 @@ static inline void canvas_put_bits(uint8_t *dest, int dest_offset, uint8_t *src,
     }
 }
 
-static void canvas_put_glyph_bits(RasterGlyph *glyph, int bpp, uint8_t *dest, int dest_stride,
-                                  Rect *bounds)
+static void canvas_put_glyph_bits(SpiceRasterGlyph *glyph, int bpp, uint8_t *dest, int dest_stride,
+                                  SpiceRect *bounds)
 {
-    Rect glyph_box;
+    SpiceRect glyph_box;
     uint8_t *src;
     int lines;
     int width;
 
-    //todo: support STRING_RASTER_TOP_DOWN
+    //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);
@@ -1298,11 +1298,11 @@ static void canvas_put_glyph_bits(RasterGlyph *glyph, int bpp, uint8_t *dest, in
     }
 }
 
-static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, String *str, int bpp, Point *pos)
+static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, SpiceString *str, int bpp, SpicePoint *pos)
 {
-    RasterGlyph *glyph = (RasterGlyph *)str->data;
-    RasterGlyph *next_glyph;
-    Rect bounds;
+    SpiceRasterGlyph *glyph = (SpiceRasterGlyph *)str->data;
+    SpiceRasterGlyph *next_glyph;
+    SpiceRect bounds;
     cairo_surface_t *str_mask;
     uint8_t *dest;
     int dest_stride;
@@ -1310,16 +1310,16 @@ static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, String *str, int
 
     ASSERT(str->length > 0);
 
-    access_test(canvas, glyph, sizeof(RasterGlyph));
+    access_test(canvas, glyph, sizeof(SpiceRasterGlyph));
     next_glyph = canvas_next_raster_glyph(glyph, bpp);
     access_test(canvas, glyph, (uint8_t*)next_glyph - (uint8_t*)glyph);
     canvas_raster_glyph_box(glyph, &bounds);
 
     for (i = 1; i < str->length; i++) {
-        Rect glyph_box;
+        SpiceRect glyph_box;
 
         glyph = next_glyph;
-        access_test(canvas, glyph, sizeof(RasterGlyph));
+        access_test(canvas, glyph, sizeof(SpiceRasterGlyph));
         next_glyph = canvas_next_raster_glyph(glyph, bpp);
         access_test(canvas, glyph, (uint8_t*)next_glyph - (uint8_t*)glyph);
         canvas_raster_glyph_box(glyph, &glyph_box);
@@ -1335,7 +1335,7 @@ static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, String *str, int
     }
     dest = cairo_image_surface_get_data(str_mask);
     dest_stride = cairo_image_surface_get_stride(str_mask);
-    glyph = (RasterGlyph *)str->data;
+    glyph = (SpiceRasterGlyph *)str->data;
     for (i = 0; i < str->length; i++) {
 #if defined(GL_CANVAS)
         canvas_put_glyph_bits(glyph, bpp, dest + (bounds.bottom - bounds.top - 1) * dest_stride,
@@ -1351,12 +1351,12 @@ static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, String *str, int
     return str_mask;
 }
 
-static inline VectotGlyph *canvas_next_vector_glyph(const VectotGlyph *glyph)
+static inline SpiceVectorGlyph *canvas_next_vector_glyph(const SpiceVectorGlyph *glyph)
 {
-    return (VectotGlyph *)((uint8_t *)(glyph + 1) + glyph->data_size);
+    return (SpiceVectorGlyph *)((uint8_t *)(glyph + 1) + glyph->data_size);
 }
 
-static cairo_surface_t *canvas_scale_surface(cairo_surface_t *src, const Rect *src_area, int width,
+static cairo_surface_t *canvas_scale_surface(cairo_surface_t *src, const SpiceRect *src_area, int width,
                                              int hight, int scale_mode)
 {
     cairo_t *cairo;
@@ -1389,8 +1389,8 @@ static cairo_surface_t *canvas_scale_surface(cairo_surface_t *src, const Rect *s
     cairo_matrix_scale(&matrix, sx, sy);
 
     cairo_pattern_set_matrix(pattern, &matrix);
-    ASSERT(scale_mode == IMAGE_SCALE_INTERPOLATE || scale_mode == IMAGE_SCALE_NEAREST);
-    cairo_pattern_set_filter(pattern, (scale_mode == IMAGE_SCALE_NEAREST) ?
+    ASSERT(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE || scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
+    cairo_pattern_set_filter(pattern, (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
                                                           CAIRO_FILTER_NEAREST : CAIRO_FILTER_GOOD);
 
     cairo_set_source(cairo, pattern);
diff --git a/common/canvas_base.h b/common/canvas_base.h
index 36529bd5..8a574e2a 100644
--- a/common/canvas_base.h
+++ b/common/canvas_base.h
@@ -28,13 +28,13 @@ typedef void (*bits_cache_put_fn_t)(void *bits_cache_opaque, uint64_t id, cairo_
 typedef cairo_surface_t *(*bits_cache_get_fn_t)(void *bits_cache_opaque, uint64_t id);
 #endif
 #ifdef CAIRO_CANVAS_CACHE
-typedef void (*palette_cache_put_fn_t)(void *palette_cache_opaque, Palette *palette);
-typedef Palette *(*palette_cache_get_fn_t)(void *palette_cache_opaque, uint64_t id);
-typedef void (*palette_cache_release_fn_t)(Palette *palette);
+typedef void (*palette_cache_put_fn_t)(void *palette_cache_opaque, SpicePalette *palette);
+typedef SpicePalette *(*palette_cache_get_fn_t)(void *palette_cache_opaque, uint64_t id);
+typedef void (*palette_cache_release_fn_t)(SpicePalette *palette);
 #endif
 
 typedef void (*glz_decode_fn_t)(void *glz_decoder_opaque, uint8_t *data,
-                                Palette *plt, void *usr_data);
+                                SpicePalette *plt, void *usr_data);
 #ifndef CAIRO_CANVAS_NO_CHUNKS
 typedef void *(*get_virt_fn_t)(void *get_virt_opaque, unsigned long addr, uint32_t add_size);
 typedef void (*validate_virt_fn_t)(void *validate_virt_opaque, unsigned long virt,
diff --git a/common/gdi_canvas.c b/common/gdi_canvas.c
index 9c7e6693..b60bef2a 100644
--- a/common/gdi_canvas.c
+++ b/common/gdi_canvas.c
@@ -35,7 +35,7 @@ struct GdiCanvas {
 struct BitmapData {
     HBITMAP hbitmap;
     HBITMAP prev_hbitmap;
-    Point pos;
+    SpicePoint pos;
     uint8_t flags;
     HDC dc;
     int cache;
@@ -321,20 +321,20 @@ static void set_path(GdiCanvas *canvas, void *addr)
     access_test(&canvas->base, data_size, sizeof(uint32_t));
     uint32_t more = *data_size;
 
-    PathSeg* seg = (PathSeg*)(data_size + 1);
+    SpicePathSeg* seg = (SpicePathSeg*)(data_size + 1);
 
     do {
-        access_test(&canvas->base, seg, sizeof(PathSeg));
+        access_test(&canvas->base, seg, sizeof(SpicePathSeg));
 
         uint32_t flags = seg->flags;
-        PointFix* point = (PointFix*)seg->data;
-        PointFix* end_point = point + seg->count;
+        SpicePointFix* point = (SpicePointFix*)seg->data;
+        SpicePointFix* end_point = point + seg->count;
         access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
         ASSERT(point < end_point);
         more -= ((unsigned long)end_point - (unsigned long)seg);
-        seg = (PathSeg*)end_point;
+        seg = (SpicePathSeg*)end_point;
 
-        if (flags & PATH_BEGIN) {
+        if (flags & SPICE_PATH_BEGIN) {
             BeginPath(canvas->dc);
             if (!MoveToEx(canvas->dc, (int)fix_to_double(point->x), (int)fix_to_double(point->y),
                           NULL)) {
@@ -344,7 +344,7 @@ static void set_path(GdiCanvas *canvas, void *addr)
             point++;
         }
 
-        if (flags & PATH_BEZIER) {
+        if (flags & SPICE_PATH_BEZIER) {
             ASSERT((point - end_point) % 3 == 0);
             for (; point + 2 < end_point; point += 3) {
                 POINT points[3];
@@ -369,9 +369,9 @@ static void set_path(GdiCanvas *canvas, void *addr)
             }
         }
 
-        if (flags & PATH_END) {
+        if (flags & SPICE_PATH_END) {
 
-            if (flags & PATH_CLOSE) {
+            if (flags & SPICE_PATH_CLOSE) {
                 if (!CloseFigure(canvas->dc)) {
                     CANVAS_ERROR("CloseFigure failed");
                 }
@@ -387,29 +387,29 @@ static void set_path(GdiCanvas *canvas, void *addr)
 
 static void set_scale_mode(GdiCanvas *canvas, uint8_t scale_mode)
 {
-    if (scale_mode == IMAGE_SCALE_INTERPOLATE) {
+    if (scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE) {
         SetStretchBltMode(canvas->dc, HALFTONE);
-    } else if (scale_mode == IMAGE_SCALE_NEAREST) {
+    } else if (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) {
         SetStretchBltMode(canvas->dc, COLORONCOLOR);
     } else {
         CANVAS_ERROR("Unknown ScaleMode");
     }
 }
 
-static void set_clip(GdiCanvas *canvas, Clip *clip)
+static void set_clip(GdiCanvas *canvas, SpiceClip *clip)
 {
     switch (clip->type) {
-    case CLIP_TYPE_NONE:
+    case SPICE_CLIP_TYPE_NONE:
         if (SelectClipRgn(canvas->dc, NULL) == ERROR) {
             CANVAS_ERROR("SelectClipRgn failed");
         }
         break;
-    case CLIP_TYPE_RECTS: {
-        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+    case SPICE_CLIP_TYPE_RECTS: {
+        uint32_t *n = (uint32_t *)SPICE_GET_ADDRESS(clip->data);
         access_test(&canvas->base, n, sizeof(uint32_t));
 
-        Rect *now = (Rect *)(n + 1);
-        Rect *end = now + *n;
+        SpiceRect *now = (SpiceRect *)(n + 1);
+        SpiceRect *end = now + *n;
         access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
 
         if (now < end) {
@@ -443,8 +443,8 @@ static void set_clip(GdiCanvas *canvas, Clip *clip)
         }
         break;
     }
-    case CLIP_TYPE_PATH:
-        set_path(canvas, GET_ADDRESS(clip->data));
+    case SPICE_CLIP_TYPE_PATH:
+        set_path(canvas, SPICE_GET_ADDRESS(clip->data));
         if (SelectClipPath(canvas->dc, RGN_COPY) == ERROR) {
             CANVAS_ERROR("Unable to SelectClipPath");
         }
@@ -631,17 +631,17 @@ static inline COLORREF get_color_ref(GdiCanvas *canvas, uint32_t color)
     return RGB(r, g, b);
 }
 
-static HBRUSH get_brush(GdiCanvas *canvas, Brush *brush)
+static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush)
 {
     HBRUSH hbrush;
 
     switch (brush->type) {
-    case BRUSH_TYPE_SOLID:
+    case SPICE_BRUSH_TYPE_SOLID:
         if (!(hbrush = CreateSolidBrush(get_color_ref(canvas, brush->u.color)))) {
             CANVAS_ERROR("CreateSolidBrush failed");
         }
         return hbrush;
-    case BRUSH_TYPE_PATTERN: {
+    case SPICE_BRUSH_TYPE_PATTERN: {
         GdiImage image;
         HBRUSH hbrush;
         cairo_surface_t *surface;
@@ -666,7 +666,7 @@ static HBRUSH get_brush(GdiCanvas *canvas, Brush *brush)
         cairo_surface_destroy(surface);
         return hbrush;
     }
-    case BRUSH_TYPE_NONE:
+    case SPICE_BRUSH_TYPE_NONE:
         return NULL;
     default:
         CANVAS_ERROR("invalid brush type");
@@ -674,13 +674,13 @@ static HBRUSH get_brush(GdiCanvas *canvas, Brush *brush)
     }
 }
 
-static HBRUSH set_brush(HDC dc, HBRUSH hbrush, Brush *brush)
+static HBRUSH set_brush(HDC dc, HBRUSH hbrush, SpiceBrush *brush)
 {
     switch (brush->type) {
-    case BRUSH_TYPE_SOLID: {
+    case SPICE_BRUSH_TYPE_SOLID: {
         return (HBRUSH)SelectObject(dc, hbrush);
     }
-    case BRUSH_TYPE_PATTERN: {
+    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)) {
@@ -711,13 +711,13 @@ uint8_t calc_rop3(uint16_t rop3_bits, int brush)
     uint8_t rop3_brush = _rop3_brush;
     uint8_t rop3_src_brush;
 
-    if (rop3_bits & ROPD_INVERS_SRC) {
+    if (rop3_bits & SPICE_ROPD_INVERS_SRC) {
         rop3_src = ~rop3_src;
     }
-    if (rop3_bits & ROPD_INVERS_BRUSH) {
+    if (rop3_bits & SPICE_ROPD_INVERS_BRUSH) {
         rop3_brush = ~rop3_brush;
     }
-    if (rop3_bits & ROPD_INVERS_DEST) {
+    if (rop3_bits & SPICE_ROPD_INVERS_DEST) {
         rop3_dest = ~rop3_dest;
     }
 
@@ -727,24 +727,24 @@ uint8_t calc_rop3(uint16_t rop3_bits, int brush)
         rop3_src_brush = rop3_src;
     }
 
-    if (rop3_bits & ROPD_OP_PUT) {
+    if (rop3_bits & SPICE_ROPD_OP_PUT) {
         rop3 = rop3_src_brush;
     }
-    if (rop3_bits & ROPD_OP_OR) {
+    if (rop3_bits & SPICE_ROPD_OP_OR) {
         rop3 = rop3_src_brush | rop3_dest;
     }
-    if (rop3_bits & ROPD_OP_AND) {
+    if (rop3_bits & SPICE_ROPD_OP_AND) {
         rop3 = rop3_src_brush & rop3_dest;
     }
-    if (rop3_bits & ROPD_OP_XOR) {
+    if (rop3_bits & SPICE_ROPD_OP_XOR) {
         rop3 = rop3_src_brush ^ rop3_dest;
     }
-    if (rop3_bits & ROPD_INVERS_RES) {
+    if (rop3_bits & SPICE_ROPD_INVERS_RES) {
         rop3 = ~rop3_dest;
     }
 
-    if (rop3_bits & ROPD_OP_BLACKNESS || rop3_bits & ROPD_OP_WHITENESS ||
-        rop3_bits & ROPD_OP_INVERS) {
+    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;
@@ -756,27 +756,27 @@ uint8_t calc_rop3_src_brush(uint16_t rop3_bits)
     uint8_t rop3_src = _rop3_src;
     uint8_t rop3_brush = _rop3_brush;
 
-    if (rop3_bits & ROPD_INVERS_SRC) {
+    if (rop3_bits & SPICE_ROPD_INVERS_SRC) {
         rop3_src = ~rop3_src;
     }
-    if (rop3_bits & ROPD_INVERS_BRUSH) {
+    if (rop3_bits & SPICE_ROPD_INVERS_BRUSH) {
         rop3_brush = ~rop3_brush;
     }
 
-    if (rop3_bits & ROPD_OP_OR) {
+    if (rop3_bits & SPICE_ROPD_OP_OR) {
         rop3 = rop3_src | rop3_brush;
     }
-    if (rop3_bits & ROPD_OP_AND) {
+    if (rop3_bits & SPICE_ROPD_OP_AND) {
         rop3 = rop3_src & rop3_brush;
     }
-    if (rop3_bits & ROPD_OP_XOR) {
+    if (rop3_bits & SPICE_ROPD_OP_XOR) {
         rop3 = rop3_src ^ rop3_brush;
     }
 
     return rop3;
 }
 
-static struct BitmapData get_mask_bitmap(struct GdiCanvas *canvas, struct QMask *mask)
+static struct BitmapData get_mask_bitmap(struct GdiCanvas *canvas, struct SpiceQMask *mask)
 {
     cairo_surface_t *surface;
     struct BitmapData bitmap;
@@ -810,7 +810,7 @@ static struct BitmapData get_mask_bitmap(struct GdiCanvas *canvas, struct QMask
     return bitmap;
 }
 
-static void gdi_draw_bitmap(HDC dest_dc, const Rect *src, const Rect *dest,
+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;
@@ -843,7 +843,7 @@ static void gdi_draw_bitmap(HDC dest_dc, const Rect *src, const Rect *dest,
     }
 }
 
-static void gdi_draw_bitmap_redrop(HDC dest_dc, const Rect *src, const Rect *dest,
+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)
 {
@@ -861,12 +861,12 @@ static void free_mask(struct BitmapData *bitmap)
 }
 
 static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
-                                 String *str, int n, Rect *dest,
-                                 Rect *src, Brush *brush)
+                                 SpiceString *str, int n, SpiceRect *dest,
+                                 SpiceRect *src, SpiceBrush *brush)
 {
     cairo_surface_t *surface;
     struct BitmapData bitmap;
-    Point pos;
+    SpicePoint pos;
     int dest_stride;
     uint8_t *bitmap_data;
     HBRUSH prev_hbrush;
@@ -941,7 +941,7 @@ static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
     free_mask(&bitmap);
 }
 
-static void gdi_draw_image(HDC dest_dc, const Rect *src, const Rect *dest,
+static void gdi_draw_image(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
                            const uint8_t *bitmap_data, int bit_stride, int bit_width,
                            int bit_height, struct BitmapData *bitmapmask, uint16_t rop,
                            int rotate)
@@ -958,7 +958,7 @@ static void gdi_draw_image(HDC dest_dc, const Rect *src, const Rect *dest,
     release_bitmap(dc, bitmap, prev_bitmap, 0);
 }
 
-static void gdi_draw_image_rop3(HDC dest_dc, const Rect *src, const Rect *dest,
+static void gdi_draw_image_rop3(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
                                 const uint8_t *bitmap_data, int bit_stride, int bit_width,
                                 int bit_height, struct BitmapData *bitmapmask, uint8_t rop3,
                                 int rotate)
@@ -975,7 +975,7 @@ static void gdi_draw_image_rop3(HDC dest_dc, const Rect *src, const Rect *dest,
     release_bitmap(dc, bitmap, prev_bitmap, 0);
 }
 
-void gdi_canvas_draw_fill(GdiCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+void gdi_canvas_draw_fill(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
 {
     HBRUSH prev_hbrush;
     HBRUSH brush;
@@ -991,13 +991,13 @@ void gdi_canvas_draw_fill(GdiCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
     set_clip(canvas, clip);
     prev_hbrush = set_brush(canvas->dc, brush, &fill->brush);
     gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
-                           fill->rop_decriptor, fill->brush.type != BRUSH_TYPE_NONE);
+                           fill->rop_decriptor, fill->brush.type != SPICE_BRUSH_TYPE_NONE);
 
     free_mask(&bitmapmask);
     unset_brush(canvas->dc, prev_hbrush);
 }
 
-void gdi_canvas_draw_copy(GdiCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+void gdi_canvas_draw_copy(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
 {
     cairo_surface_t *surface;
     GdiImage image;
@@ -1035,18 +1035,18 @@ void gdi_canvas_draw_copy(GdiCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
     cairo_surface_destroy(surface);
 }
 
-void gdi_canvas_put_image(GdiCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *src_data,
+void gdi_canvas_put_image(GdiCanvas *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)
 {
-    Rect src;
+    SpiceRect src;
     src.top = 0;
     src.bottom = src_height;
     src.left = 0;
     src.right = src_width;
 
     Lock lock(*canvas->lock);
-    set_scale_mode(canvas, IMAGE_SCALE_NEAREST);
+    set_scale_mode(canvas, SPICE_IMAGE_SCALE_MODE_NEAREST);
     if (clip) {
         if (clip->num_rects == 0) {
             return;
@@ -1090,15 +1090,15 @@ void gdi_canvas_put_image(GdiCanvas *canvas, HDC dc, const Rect *dest, const uin
 
     if (dc) {
         gdi_draw_bitmap_redrop(canvas->dc, &src, dest, dc,
-                               NULL, ROPD_OP_PUT, 0);
+                               NULL, SPICE_ROPD_OP_PUT, 0);
     } else {
         gdi_draw_image(canvas->dc, &src, dest, src_data,
-                       src_stride, src_width, src_height, NULL, ROPD_OP_PUT, 0);
+                       src_stride, src_width, src_height, NULL, SPICE_ROPD_OP_PUT, 0);
     }
 }
 
-static void gdi_draw_bitmap_transparent(GdiCanvas *canvas, HDC dest_dc, const Rect *src,
-                                        const Rect *dest, HDC src_dc, uint32_t color)
+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,
@@ -1106,8 +1106,8 @@ static void gdi_draw_bitmap_transparent(GdiCanvas *canvas, HDC dest_dc, const Re
                    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 Rect *src,
-                                       const Rect *dest, const uint8_t *bitmap_data,
+static void gdi_draw_image_transparent(GdiCanvas *canvas, HDC dest_dc, const SpiceRect *src,
+                                       const SpiceRect *dest, const uint8_t *bitmap_data,
                                        int bit_stride, int bit_width, int bit_height,
                                        uint32_t color, int rotate)
 {
@@ -1123,8 +1123,8 @@ static void gdi_draw_image_transparent(GdiCanvas *canvas, HDC dest_dc, const Rec
     release_bitmap(dc, bitmap, prev_bitmap, 0);
 }
 
-void gdi_canvas_draw_transparent(GdiCanvas *canvas, Rect *bbox, Clip *clip,
-                                 Transparent* transparent)
+void gdi_canvas_draw_transparent(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip,
+                                 SpiceTransparent* transparent)
 {
     cairo_surface_t *surface;
     GdiImage image;
@@ -1156,7 +1156,7 @@ void gdi_canvas_draw_transparent(GdiCanvas *canvas, Rect *bbox, Clip *clip,
     cairo_surface_destroy(surface);
 }
 
-static void gdi_draw_bitmap_alpha(HDC dest_dc, const Rect *src, const Rect *dest,
+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;
@@ -1178,7 +1178,7 @@ static void gdi_draw_bitmap_alpha(HDC dest_dc, const Rect *src, const Rect *dest
     }
 }
 
-static void gdi_draw_image_alpha(HDC dest_dc, const Rect *src, const Rect *dest,
+static void gdi_draw_image_alpha(HDC dest_dc, const SpiceRect *src, const SpiceRect *dest,
                                  const uint8_t *bitmap_data, int bit_stride,
                                  int bit_width, int bit_height, uint8_t alpha,
                                  int rotate, int use_bitmap_alpha)
@@ -1195,7 +1195,7 @@ static void gdi_draw_image_alpha(HDC dest_dc, const Rect *src, const Rect *dest,
     release_bitmap(dc, bitmap, prev_bitmap, 0);
 }
 
-void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend)
 {
     cairo_surface_t *surface;
     GdiImage image;
@@ -1229,7 +1229,7 @@ void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, Alph
     cairo_surface_destroy(surface);
 }
 
-void gdi_canvas_draw_opaque(GdiCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+void gdi_canvas_draw_opaque(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
 {
     cairo_surface_t *surface;
     GdiImage image;
@@ -1274,7 +1274,7 @@ void gdi_canvas_draw_opaque(GdiCanvas *canvas, Rect *bbox, Clip *clip, Opaque *o
     cairo_surface_destroy(surface);
 }
 
-void gdi_canvas_draw_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+void gdi_canvas_draw_blend(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
 {
     cairo_surface_t *surface;
     GdiImage image;
@@ -1311,7 +1311,7 @@ void gdi_canvas_draw_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blend *ble
     cairo_surface_destroy(surface);
 }
 
-void gdi_canvas_draw_blackness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+void gdi_canvas_draw_blackness(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
 {
     struct BitmapData bitmapmask;
 
@@ -1324,7 +1324,7 @@ void gdi_canvas_draw_blackness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blackn
     free_mask(&bitmapmask);
 }
 
-void gdi_canvas_draw_invers(GdiCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+void gdi_canvas_draw_invers(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
 {
     struct BitmapData bitmapmask;
 
@@ -1337,7 +1337,7 @@ void gdi_canvas_draw_invers(GdiCanvas *canvas, Rect *bbox, Clip *clip, Invers *i
     free_mask(&bitmapmask);
 }
 
-void gdi_canvas_draw_whiteness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+void gdi_canvas_draw_whiteness(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
 {
     struct BitmapData bitmapmask;
 
@@ -1350,7 +1350,7 @@ void gdi_canvas_draw_whiteness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Whiten
     free_mask(&bitmapmask);
 }
 
-void gdi_canvas_draw_rop3(GdiCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+void gdi_canvas_draw_rop3(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
 {
     cairo_surface_t *surface;
     GdiImage image;
@@ -1392,7 +1392,7 @@ void gdi_canvas_draw_rop3(GdiCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
     cairo_surface_destroy(surface);
 }
 
-void gdi_canvas_copy_bits(GdiCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+void gdi_canvas_copy_bits(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     Lock lock(*canvas->lock);
 
@@ -1402,9 +1402,9 @@ void gdi_canvas_copy_bits(GdiCanvas *canvas, Rect *bbox, Clip *clip, Point *src_
            bbox->bottom - bbox->top, canvas->dc, src_pos->x, src_pos->y, SRCCOPY);
 }
 
-void gdi_canvas_draw_text(GdiCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+void gdi_canvas_draw_text(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
 {
-    String *str;
+    SpiceString *str;
 
     Lock lock(*canvas->lock);
     set_clip(canvas, clip);
@@ -1422,23 +1422,23 @@ void gdi_canvas_draw_text(GdiCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
         unset_brush(canvas->dc, prev_hbrush);
     }
 
-    str = (String *)GET_ADDRESS(text->str);
+    str = (SpiceString *)SPICE_GET_ADDRESS(text->str);
 
-    if (str->flags & STRING_RASTER_A1) {
-        Rect dest;
-        Rect src;
+    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 & STRING_RASTER_A4) {
-        Rect dest;
-        Rect src;
+    } 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 & STRING_RASTER_A8) {
+    } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
         WARN("untested path A8 glyphs, doing nothing");
         if (0) {
-            Rect dest;
-            Rect src;
+            SpiceRect dest;
+            SpiceRect src;
 
             draw_str_mask_bitmap(canvas, str, 8, &dest, &src, &text->fore_brush);
         }
@@ -1452,11 +1452,11 @@ void gdi_canvas_draw_text(GdiCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
 static int get_join_style(uint8_t join_style)
 {
     switch (join_style) {
-    case LINE_JOIN_ROUND:
+    case SPICE_LINE_JOIN_ROUND:
         return PS_JOIN_ROUND;
-    case LINE_JOIN_BEVEL:
+    case SPICE_LINE_JOIN_BEVEL:
         return PS_JOIN_BEVEL;
-    case LINE_JOIN_MITER:
+    case SPICE_LINE_JOIN_MITER:
         return PS_JOIN_MITER;
     default:
         CANVAS_ERROR("bad join style %d", join_style);
@@ -1466,20 +1466,20 @@ static int get_join_style(uint8_t join_style)
 static int get_cap(int end_style)
 {
     switch (end_style) {
-    case LINE_CAP_ROUND:
+    case SPICE_LINE_CAP_ROUND:
         return PS_ENDCAP_ROUND;
-    case LINE_CAP_SQUARE:
+    case SPICE_LINE_CAP_SQUARE:
         return PS_ENDCAP_SQUARE;
-    case LINE_CAP_BUTT:
+    case SPICE_LINE_CAP_BUTT:
         return PS_ENDCAP_FLAT;
     default:
         CANVAS_ERROR("bad end style %d", end_style);
     }
 }
 
-static uint32_t *gdi_get_userstyle(GdiCanvas *canvas, UINT8 nseg, ADDRESS addr, int start_is_gap)
+static uint32_t *gdi_get_userstyle(GdiCanvas *canvas, UINT8 nseg, SPICE_ADDRESS addr, int start_is_gap)
 {
-    FIXED28_4* style = (FIXED28_4*)GET_ADDRESS(addr);
+    SPICE_FIXED28_4* style = (SPICE_FIXED28_4*)SPICE_GET_ADDRESS(addr);
     double offset = 0;
     uint32_t *local_style;
     int i;
@@ -1508,7 +1508,7 @@ static uint32_t *gdi_get_userstyle(GdiCanvas *canvas, UINT8 nseg, ADDRESS addr,
     return local_style;
 }
 
-void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+void gdi_canvas_draw_stroke(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
 {
     HPEN hpen;
     HPEN prev_hpen;
@@ -1518,7 +1518,7 @@ void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *s
     uint32_t *user_style = NULL;
     cairo_surface_t *surface = NULL;
 
-    if (stroke->brush.type == BRUSH_TYPE_PATTERN) {
+    if (stroke->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
         surface = canvas_get_image(&canvas->base, stroke->brush.u.pattern.pat);
     }
 
@@ -1526,49 +1526,49 @@ void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *s
     set_clip(canvas, clip);
 
     switch (stroke->fore_mode) {
-    case ROPD_OP_WHITENESS:
+    case SPICE_ROPD_OP_WHITENESS:
         SetROP2(canvas->dc, R2_WHITE);    //0
         break;
-    case ROPD_OP_BLACKNESS:
+    case SPICE_ROPD_OP_BLACKNESS:
         SetROP2(canvas->dc, R2_BLACK);    //1
         break;
-    case ROPD_OP_INVERS:
+    case SPICE_ROPD_OP_INVERS:
         SetROP2(canvas->dc, R2_NOT);    //Dn
         break;
-    case ROPD_OP_PUT:
+    case SPICE_ROPD_OP_PUT:
         SetROP2(canvas->dc, R2_COPYPEN);    //P
         break;
-    case ROPD_OP_OR:
+    case SPICE_ROPD_OP_OR:
         SetROP2(canvas->dc, R2_MERGEPEN);    //DPo
         break;
-    case ROPD_OP_XOR:
+    case SPICE_ROPD_OP_XOR:
         SetROP2(canvas->dc, R2_XORPEN);    //DPx
         break;
-    case ROPD_OP_AND:
+    case SPICE_ROPD_OP_AND:
         SetROP2(canvas->dc, R2_MASKPEN);    //DPa
         break;
-    case ROPD_INVERS_BRUSH | ROPD_OP_PUT:    //Pn
+    case SPICE_ROPD_INVERS_BRUSH | SPICE_ROPD_OP_PUT:    //Pn
         SetROP2(canvas->dc, R2_NOTCOPYPEN);
         break;
-    case ROPD_OP_XOR | ROPD_INVERS_RES:
+    case SPICE_ROPD_OP_XOR | SPICE_ROPD_INVERS_RES:
         SetROP2(canvas->dc, R2_NOTXORPEN);    //DPxn
         break;
-    case ROPD_OP_OR | ROPD_INVERS_RES:
+    case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_RES:
         SetROP2(canvas->dc, R2_NOTMERGEPEN);    //DPon
         break;
-    case ROPD_OP_AND | ROPD_INVERS_RES:
+    case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_RES:
         SetROP2(canvas->dc, R2_NOTMASKPEN);    //DPan
         break;
-    case ROPD_INVERS_DEST | ROPD_OP_AND:
+    case SPICE_ROPD_INVERS_DEST | SPICE_ROPD_OP_AND:
         SetROP2(canvas->dc, R2_MASKPENNOT);    //PDna
         break;
-    case ROPD_INVERS_BRUSH | ROPD_OP_AND:
+    case SPICE_ROPD_INVERS_BRUSH | SPICE_ROPD_OP_AND:
         SetROP2(canvas->dc, R2_MASKNOTPEN);    //DPna
         break;
-    case ROPD_OP_OR | ROPD_INVERS_BRUSH:
+    case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_BRUSH:
         SetROP2(canvas->dc, R2_MERGENOTPEN);    //DPno
         break;
-    case ROPD_OP_OR | ROPD_INVERS_DEST:
+    case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_DEST:
         SetROP2(canvas->dc, R2_MERGEPENNOT);    //PDno
         break;
     default:
@@ -1576,11 +1576,11 @@ void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *s
     }
 
 
-    if (stroke->brush.type == BRUSH_TYPE_SOLID) {
+    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 == BRUSH_TYPE_PATTERN) {
+    } else if (stroke->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
 #if 0
         struct {
             BITMAPINFO inf;
@@ -1639,10 +1639,10 @@ void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *s
     SetMiterLimit(canvas->dc, (FLOAT)fix_to_double(stroke->attr.miter_limit), &old_miter);
 #endif
 
-    if (stroke->attr.flags & LINE_ATTR_STYLED) {
+    if (stroke->attr.flags & SPICE_LINE_ATTR_STYLED) {
         user_style = gdi_get_userstyle(canvas, stroke->attr.style_nseg,
                                        stroke->attr.style,
-                                       !!(stroke->attr.flags & LINE_ATTR_STARTGAP));
+                                       !!(stroke->attr.flags & SPICE_LINE_ATTR_STARTGAP));
         hpen = ExtCreatePen(PS_GEOMETRIC | ps_join | line_cap | PS_USERSTYLE,
                             (uint32_t)fix_to_double(stroke->attr.width),
                             &logbrush, stroke->attr.style_nseg, (DWORD *)user_style);
@@ -1653,7 +1653,7 @@ void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *s
     }
     prev_hpen = (HPEN)SelectObject(canvas->dc, hpen);
 
-    set_path(canvas, GET_ADDRESS(stroke->path));
+    set_path(canvas, SPICE_GET_ADDRESS(stroke->path));
 
     StrokePath(canvas->dc);
 
@@ -1661,7 +1661,7 @@ void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *s
     DeleteObject(hpen);
 
 #if 0
-    if (stroke->brush.type == BRUSH_TYPE_PATTERN) {
+    if (stroke->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
         GlobalFree((HGLOBAL)logbrush.lbHatch);
     }
 #endif
diff --git a/common/gdi_canvas.h b/common/gdi_canvas.h
index 02669c6a..0f518508 100644
--- a/common/gdi_canvas.h
+++ b/common/gdi_canvas.h
@@ -34,21 +34,21 @@ typedef struct {
     uint8_t *pixels;
 } GdiImage;
 
-void gdi_canvas_draw_fill(GdiCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill);
-void gdi_canvas_draw_copy(GdiCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy);
-void gdi_canvas_draw_opaque(GdiCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
-void gdi_canvas_copy_bits(GdiCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos);
-void gdi_canvas_draw_text(GdiCanvas *canvas, Rect *bbox, Clip *clip, Text *text);
-void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
-void gdi_canvas_draw_rop3(GdiCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
-void gdi_canvas_draw_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend);
-void gdi_canvas_draw_blackness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
-void gdi_canvas_draw_whiteness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
-void gdi_canvas_draw_invers(GdiCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers);
-void gdi_canvas_draw_transparent(GdiCanvas *canvas, Rect *bbox, Clip *clip,
-                                 Transparent* transparent);
-void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
-void gdi_canvas_put_image(GdiCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *src_data,
+void gdi_canvas_draw_fill(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+void gdi_canvas_draw_copy(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+void gdi_canvas_draw_opaque(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+void gdi_canvas_copy_bits(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+void gdi_canvas_draw_text(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
+void gdi_canvas_draw_stroke(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+void gdi_canvas_draw_rop3(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+void gdi_canvas_draw_blend(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+void gdi_canvas_draw_blackness(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+void gdi_canvas_draw_whiteness(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+void gdi_canvas_draw_invers(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+void gdi_canvas_draw_transparent(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip,
+                                 SpiceTransparent* transparent);
+void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
+void gdi_canvas_put_image(GdiCanvas *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);
 void gdi_canvas_clear(GdiCanvas *canvas);
diff --git a/common/gl_canvas.c b/common/gl_canvas.c
index 73c3c517..eaf1e91e 100644
--- a/common/gl_canvas.c
+++ b/common/gl_canvas.c
@@ -116,25 +116,25 @@ static GLCPath get_path(GLCanvas *canvas, void *addr)
     access_test(&canvas->base, data_size, sizeof(uint32_t));
     uint32_t more = *data_size;
 
-    PathSeg* seg = (PathSeg*)(data_size + 1);
+    SpicePathSeg* seg = (SpicePathSeg*)(data_size + 1);
 
     do {
-        access_test(&canvas->base, seg, sizeof(PathSeg));
+        access_test(&canvas->base, seg, sizeof(SpicePathSeg));
 
         uint32_t flags = seg->flags;
-        PointFix* point = (PointFix*)seg->data;
-        PointFix* end_point = point + seg->count;
+        SpicePointFix* point = (SpicePointFix*)seg->data;
+        SpicePointFix* end_point = point + seg->count;
         access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
         ASSERT(point < end_point);
         more -= ((unsigned long)end_point - (unsigned long)seg);
-        seg = (PathSeg*)end_point;
+        seg = (SpicePathSeg*)end_point;
 
-        if (flags & PATH_BEGIN) {
+        if (flags & SPICE_PATH_BEGIN) {
             glc_path_move_to(path, fix_to_double(point->x), fix_to_double(point->y));
             point++;
         }
 
-        if (flags & PATH_BEZIER) {
+        if (flags & SPICE_PATH_BEZIER) {
             ASSERT((point - end_point) % 3 == 0);
             for (; point + 2 < end_point; point += 3) {
                 glc_path_curve_to(path,
@@ -147,8 +147,8 @@ static GLCPath get_path(GLCanvas *canvas, void *addr)
                 glc_path_line_to(path, fix_to_double(point->x), fix_to_double(point->y));
             }
         }
-        if (flags & PATH_END) {
-            if (flags & PATH_CLOSE) {
+        if (flags & SPICE_PATH_END) {
+            if (flags & SPICE_PATH_CLOSE) {
                 glc_path_close(path);
             }
         }
@@ -164,19 +164,19 @@ static GLCPath get_path(GLCanvas *canvas, void *addr)
     (dest)->height = (src)->bottom - (src)->top;    \
 }
 
-static void set_clip(GLCanvas *canvas, Rect *bbox, Clip *clip)
+static void set_clip(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip)
 {
     GLCRect rect;
     glc_clip_reset(canvas->glc);
 
     switch (clip->type) {
-    case CLIP_TYPE_NONE:
+    case SPICE_CLIP_TYPE_NONE:
         break;
-    case CLIP_TYPE_RECTS: {
-        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+    case SPICE_CLIP_TYPE_RECTS: {
+        uint32_t *n = (uint32_t *)SPICE_GET_ADDRESS(clip->data);
         access_test(&canvas->base, n, sizeof(uint32_t));
-        Rect *now = (Rect *)(n + 1);
-        Rect *end = now + *n;
+        SpiceRect *now = (SpiceRect *)(n + 1);
+        SpiceRect *end = now + *n;
         access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
 
         if (*n == 0) {
@@ -195,8 +195,8 @@ static void set_clip(GLCanvas *canvas, Rect *bbox, Clip *clip)
         }
         break;
     }
-    case CLIP_TYPE_PATH: {
-        GLCPath path = get_path(canvas, GET_ADDRESS(clip->data));
+    case SPICE_CLIP_TYPE_PATH: {
+        GLCPath path = get_path(canvas, SPICE_GET_ADDRESS(clip->data));
         glc_clip_path(canvas->glc, path, GLC_CLIP_OP_SET);
         glc_path_destroy(path);
         break;
@@ -206,7 +206,7 @@ static void set_clip(GLCanvas *canvas, Rect *bbox, Clip *clip)
     }
 }
 
-static void set_mask(GLCanvas *canvas, QMask *mask, int x, int y)
+static void set_mask(GLCanvas *canvas, SpiceQMask *mask, int x, int y)
 {
     cairo_surface_t *surface;
 
@@ -246,10 +246,10 @@ static inline void surface_to_image(GLCanvas *canvas, cairo_surface_t *surface,
     }
 }
 
-static void set_brush(GLCanvas *canvas, Brush *brush)
+static void set_brush(GLCanvas *canvas, SpiceBrush *brush)
 {
     switch (brush->type) {
-    case BRUSH_TYPE_SOLID: {
+    case SPICE_BRUSH_TYPE_SOLID: {
         uint32_t color = brush->u.color;
         double r, g, b;
 
@@ -261,7 +261,7 @@ static void set_brush(GLCanvas *canvas, Brush *brush)
         glc_set_rgb(canvas->glc, r, g, b);
         break;
     }
-    case BRUSH_TYPE_PATTERN: {
+    case SPICE_BRUSH_TYPE_PATTERN: {
         GLCImage image;
         GLCPattern pattern;
         cairo_surface_t *surface;
@@ -275,7 +275,7 @@ static void set_brush(GLCanvas *canvas, Brush *brush)
         glc_set_pattern(canvas->glc, pattern);
         glc_pattern_destroy(pattern);
     }
-    case BRUSH_TYPE_NONE:
+    case SPICE_BRUSH_TYPE_NONE:
         return;
     default:
         CANVAS_ERROR("invalid brush type");
@@ -287,52 +287,52 @@ static void set_op(GLCanvas *canvas, UINT16 rop_decriptor)
     GLCOp op;
 
     switch (rop_decriptor) {
-    case ROPD_OP_PUT:
+    case SPICE_ROPD_OP_PUT:
         op = GLC_OP_COPY;
         break;
-    case ROPD_OP_XOR:
+    case SPICE_ROPD_OP_XOR:
         op = GLC_OP_XOR;
         break;
-    case ROPD_OP_BLACKNESS:
+    case SPICE_ROPD_OP_BLACKNESS:
         op = GLC_OP_CLEAR;
         break;
-    case ROPD_OP_WHITENESS:
+    case SPICE_ROPD_OP_WHITENESS:
         op = GLC_OP_SET;
         break;
-    case ROPD_OP_PUT | ROPD_INVERS_BRUSH:
-    case ROPD_OP_PUT | ROPD_INVERS_SRC:
+    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 ROPD_OP_INVERS:
+    case SPICE_ROPD_OP_INVERS:
         op = GLC_OP_INVERT;
         break;
-    case ROPD_OP_AND:
+    case SPICE_ROPD_OP_AND:
         op = GLC_OP_AND;
         break;
-    case ROPD_OP_AND | ROPD_INVERS_RES:
+    case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_RES:
         op = GLC_OP_NAND;
         break;
-    case ROPD_OP_OR:
+    case SPICE_ROPD_OP_OR:
         op = GLC_OP_OR;
         break;
-    case ROPD_OP_OR | ROPD_INVERS_RES:
+    case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_RES:
         op = GLC_OP_NOR;
         break;
-    case ROPD_OP_XOR | ROPD_INVERS_RES:
+    case SPICE_ROPD_OP_XOR | SPICE_ROPD_INVERS_RES:
         op = GLC_OP_EQUIV;
         break;
-    case ROPD_OP_AND | ROPD_INVERS_DEST:
+    case SPICE_ROPD_OP_AND | SPICE_ROPD_INVERS_DEST:
         op = GLC_OP_AND_REVERSE;
         break;
-    case ROPD_OP_AND | ROPD_INVERS_BRUSH:
-    case ROPD_OP_AND | ROPD_INVERS_SRC:
+    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 ROPD_OP_OR | ROPD_INVERS_DEST:
+    case SPICE_ROPD_OP_OR | SPICE_ROPD_INVERS_DEST:
         op = GLC_OP_OR_REVERSE;
         break;
-    case ROPD_OP_OR | ROPD_INVERS_BRUSH:
-    case ROPD_OP_OR | ROPD_INVERS_SRC:
+    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:
@@ -342,7 +342,7 @@ static void set_op(GLCanvas *canvas, UINT16 rop_decriptor)
     glc_set_op(canvas->glc, op);
 }
 
-void gl_canvas_draw_fill(GLCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+void gl_canvas_draw_fill(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill)
 {
     GLCRect rect;
     set_clip(canvas, bbox, clip);
@@ -355,7 +355,7 @@ void gl_canvas_draw_fill(GLCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
     glc_flush(canvas->glc);
 }
 
-void gl_canvas_draw_copy(GLCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+void gl_canvas_draw_copy(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy)
 {
     cairo_surface_t *surface;
     GLCRecti src;
@@ -377,7 +377,7 @@ void gl_canvas_draw_copy(GLCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
     glc_flush(canvas->glc);
 }
 
-void gl_canvas_draw_opaque(GLCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+void gl_canvas_draw_opaque(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque)
 {
     cairo_surface_t *surface;
     GLCRecti src;
@@ -388,7 +388,7 @@ void gl_canvas_draw_opaque(GLCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opa
     set_clip(canvas, bbox, clip);
     set_mask(canvas, &opaque->mask, bbox->left, bbox->top);
 
-    glc_set_op(canvas->glc, (opaque->rop_decriptor & ROPD_INVERS_SRC) ? GLC_OP_COPY_INVERTED :
+    glc_set_op(canvas->glc, (opaque->rop_decriptor & SPICE_ROPD_INVERS_SRC) ? GLC_OP_COPY_INVERTED :
                GLC_OP_COPY);
     surface = canvas_get_image(&canvas->base, opaque->src_bitmap);
     surface_to_image(canvas, surface, &image, 0);
@@ -398,14 +398,14 @@ void gl_canvas_draw_opaque(GLCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opa
     cairo_surface_destroy(surface);
 
     set_brush(canvas, &opaque->brush);
-    set_op(canvas, opaque->rop_decriptor & ~ROPD_INVERS_SRC);
+    set_op(canvas, opaque->rop_decriptor & ~SPICE_ROPD_INVERS_SRC);
     SET_GLC_RECT(&fill_rect, bbox);
     glc_fill_rect(canvas->glc, &fill_rect);
 
     glc_flush(canvas->glc);
 }
 
-void gl_canvas_draw_alpha_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd *alpha_blend)
+void gl_canvas_draw_alpha_blend(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd *alpha_blend)
 {
     cairo_surface_t *surface;
     GLCRecti src;
@@ -426,7 +426,7 @@ void gl_canvas_draw_alpha_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, AlphaB
     glc_flush(canvas->glc);
 }
 
-void gl_canvas_draw_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+void gl_canvas_draw_blend(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend)
 {
     cairo_surface_t *surface;
     GLCRecti src;
@@ -447,7 +447,7 @@ void gl_canvas_draw_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend
     glc_flush(canvas->glc);
 }
 
-void gl_canvas_draw_transparent(GLCanvas *canvas, Rect *bbox, Clip *clip, Transparent *transparent)
+void gl_canvas_draw_transparent(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent *transparent)
 {
     cairo_surface_t *surface;
     cairo_surface_t *trans_surf;
@@ -474,7 +474,7 @@ void gl_canvas_draw_transparent(GLCanvas *canvas, Rect *bbox, Clip *clip, Transp
     glc_flush(canvas->glc);
 }
 
-static inline void fill_common(GLCanvas *canvas, Rect *bbox, Clip *clip, QMask * mask, GLCOp op)
+static inline void fill_common(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceQMask * mask, GLCOp op)
 {
     GLCRect rect;
 
@@ -485,27 +485,27 @@ static inline void fill_common(GLCanvas *canvas, Rect *bbox, Clip *clip, QMask *
     glc_fill_rect(canvas->glc, &rect);
 }
 
-void gl_canvas_draw_whiteness(GLCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+void gl_canvas_draw_whiteness(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness)
 {
     fill_common(canvas, bbox, clip, &whiteness->mask, GLC_OP_SET);
 }
 
-void gl_canvas_draw_blackness(GLCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+void gl_canvas_draw_blackness(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness)
 {
     fill_common(canvas, bbox, clip, &blackness->mask, GLC_OP_CLEAR);
 }
 
-void gl_canvas_draw_invers(GLCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+void gl_canvas_draw_invers(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers)
 {
     fill_common(canvas, bbox, clip, &invers->mask, GLC_OP_INVERT);
 }
 
-void gl_canvas_draw_rop3(GLCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+void gl_canvas_draw_rop3(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3)
 {
     cairo_surface_t *d;
     cairo_surface_t *s;
     GLCImage image;
-    Point src_pos;
+    SpicePoint src_pos;
     uint8_t *data_opp;
     int src_stride;
 
@@ -561,9 +561,9 @@ void gl_canvas_draw_rop3(GLCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
         CANVAS_ERROR("bad src bitmap size");
     }
 
-    if (rop3->brush.type == BRUSH_TYPE_PATTERN) {
+    if (rop3->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
         cairo_surface_t *p = canvas_get_image(&canvas->base, rop3->brush.u.pattern.pat);
-        Point pat_pos;
+        SpicePoint pat_pos;
 
         pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % cairo_image_surface_get_width(p);
 
@@ -601,7 +601,7 @@ void gl_canvas_draw_rop3(GLCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
     cairo_surface_destroy(d);
 }
 
-void gl_canvas_draw_stroke(GLCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+void gl_canvas_draw_stroke(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke)
 {
     GLCPath path;
 
@@ -610,20 +610,20 @@ void gl_canvas_draw_stroke(GLCanvas *canvas, Rect *bbox, Clip *clip, Stroke *str
     set_op(canvas, stroke->fore_mode);
     set_brush(canvas, &stroke->brush);
 
-    if (stroke->attr.flags & LINE_ATTR_STYLED) {
-        WARN("LINE_ATTR_STYLED");
+    if (stroke->attr.flags & SPICE_LINE_ATTR_STYLED) {
+        WARN("SPICE_LINE_ATTR_STYLED");
     }
     glc_set_line_width(canvas->glc, fix_to_double(stroke->attr.width));
 
-    path = get_path(canvas, GET_ADDRESS(stroke->path));
+    path = get_path(canvas, SPICE_GET_ADDRESS(stroke->path));
     glc_stroke_path(canvas->glc, path);
     glc_path_destroy(path);
 }
 
-void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+void gl_canvas_draw_text(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text)
 {
     GLCRect rect;
-    String *str;
+    SpiceString *str;
 
     set_clip(canvas, bbox, clip);
     glc_clear_mask(canvas->glc, GLC_MASK_A);
@@ -635,11 +635,11 @@ void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
         glc_fill_rect(canvas->glc, &rect);
     }
 
-    str = (String *)GET_ADDRESS(text->str);
+    str = (SpiceString *)SPICE_GET_ADDRESS(text->str);
     set_brush(canvas, &text->fore_brush);
     set_op(canvas, text->fore_mode);
-    if (str->flags & STRING_RASTER_A1) {
-        Point pos;
+    if (str->flags & SPICE_STRING_FLAGS_RASTER_A1) {
+        SpicePoint pos;
         cairo_surface_t *mask = canvas_get_str_mask(&canvas->base, str, 1, &pos);
         _glc_fill_mask(canvas->glc, pos.x, pos.y,
                        cairo_image_surface_get_width(mask),
@@ -647,8 +647,8 @@ void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
                        cairo_image_surface_get_stride(mask),
                        cairo_image_surface_get_data(mask));
         cairo_surface_destroy(mask);
-    } else if (str->flags & STRING_RASTER_A4) {
-        Point pos;
+    } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A4) {
+        SpicePoint pos;
         cairo_surface_t *mask = canvas_get_str_mask(&canvas->base, str, 4, &pos);
         glc_fill_alpha(canvas->glc, pos.x, pos.y,
                        cairo_image_surface_get_width(mask),
@@ -657,10 +657,10 @@ void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
                        cairo_image_surface_get_data(mask));
 
         cairo_surface_destroy(mask);
-    } else if (str->flags & STRING_RASTER_A8) {
+    } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
         WARN("untested path A8 glyphs, doing nothing");
         if (0) {
-            Point pos;
+            SpicePoint pos;
             cairo_surface_t *mask = canvas_get_str_mask(&canvas->base, str, 8, &pos);
             glc_fill_alpha(canvas->glc, pos.x, pos.y,
                            cairo_image_surface_get_width(mask),
@@ -684,7 +684,7 @@ void gl_canvas_clear(GLCanvas *canvas)
     glc_flush(canvas->glc);
 }
 
-void gl_canvas_copy_pixels(GLCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+void gl_canvas_copy_pixels(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos)
 {
     set_clip(canvas, bbox, clip);
     glc_clear_mask(canvas->glc, GLC_MASK_A);
@@ -693,7 +693,7 @@ void gl_canvas_copy_pixels(GLCanvas *canvas, Rect *bbox, Clip *clip, Point *src_
                     bbox->right - bbox->left, bbox->bottom - bbox->top);
 }
 
-void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area)
+void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, const SpiceRect *area)
 {
     GLCImage image;
 
@@ -706,7 +706,7 @@ void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, con
     glc_read_pixels(canvas->glc, area->left, area->top, &image);
 }
 
-void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const Rect *rects)
+void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const SpiceRect *rects)
 {
     GLCRect *glc_rects = (GLCRect *)malloc(num_rect * sizeof(GLCRect));
     GLCRect *now = glc_rects;
@@ -720,7 +720,7 @@ void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const Rect *rects)
     free(glc_rects);
 }
 
-void gl_canvas_put_image(GLCanvas *canvas, const Rect *dest, const uint8_t *src_data,
+void gl_canvas_put_image(GLCanvas *canvas, const SpiceRect *dest, const uint8_t *src_data,
                          uint32_t src_width, uint32_t src_height, int src_stride,
                          const QRegion *clip)
 {
diff --git a/common/gl_canvas.h b/common/gl_canvas.h
index 2e3dd7c2..177c99d0 100644
--- a/common/gl_canvas.h
+++ b/common/gl_canvas.h
@@ -22,29 +22,29 @@
 
 typedef struct GLCanvas GLCanvas;
 
-void gl_canvas_draw_fill(GLCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill);
-void gl_canvas_draw_copy(GLCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy);
-void gl_canvas_draw_opaque(GLCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
-void gl_canvas_draw_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend);
-void gl_canvas_draw_alpha_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd *alpha_blend);
-void gl_canvas_draw_transparent(GLCanvas *canvas, Rect *bbox, Clip *clip, Transparent *transparent);
-void gl_canvas_draw_whiteness(GLCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
-void gl_canvas_draw_blackness(GLCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
-void gl_canvas_draw_invers(GLCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers);
-void gl_canvas_draw_rop3(GLCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
-void gl_canvas_draw_stroke(GLCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
-void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text);
+void gl_canvas_draw_fill(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+void gl_canvas_draw_copy(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+void gl_canvas_draw_opaque(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+void gl_canvas_draw_blend(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+void gl_canvas_draw_alpha_blend(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd *alpha_blend);
+void gl_canvas_draw_transparent(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent *transparent);
+void gl_canvas_draw_whiteness(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+void gl_canvas_draw_blackness(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+void gl_canvas_draw_invers(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+void gl_canvas_draw_rop3(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+void gl_canvas_draw_stroke(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+void gl_canvas_draw_text(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
 
-void gl_canvas_copy_pixels(GLCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos);
-void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area);
+void gl_canvas_copy_pixels(GLCanvas *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, const SpiceRect *area);
 
-void gl_canvas_put_image(GLCanvas *canvas, const Rect *dest, const uint8_t *src_data,
+void gl_canvas_put_image(GLCanvas *canvas, const SpiceRect *dest, const uint8_t *src_data,
                          uint32_t src_width, uint32_t src_height, int src_stride,
                          const QRegion *clip);
 
 void gl_canvas_clear(GLCanvas *canvas);
 
-void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const Rect *rects);
+void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const SpiceRect *rects);
 void gl_canvas_clear_top_mask(GLCanvas *canvas);
 
 #ifdef CAIRO_CANVAS_ACCESS_TEST
diff --git a/common/lz.c b/common/lz.c
index eac44af6..e0e112ec 100644
--- a/common/lz.c
+++ b/common/lz.c
@@ -77,7 +77,7 @@ typedef struct Encoder {
     LzUsrContext    *usr;
 
     LzImageType type;
-    const Palette    *palette;    // for decoding images with palettes to rgb
+    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
@@ -577,7 +577,7 @@ int lz_encode(LzContext *lz, LzImageType type, int width, int height, int top_do
 */
 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 Palette *palette)
+                     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;
diff --git a/common/lz.h b/common/lz.h
index 074f633b..3fe1b4c8 100644
--- a/common/lz.h
+++ b/common/lz.h
@@ -52,7 +52,7 @@ int lz_encode(LzContext *lz, LzImageType type, int width, int height, int top_do
 */
 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 Palette *palette);
+                     int *out_n_pixels, int *out_top_down, const SpicePalette *palette);
 
 /*
         to_type = the image output type.
diff --git a/common/rect.h b/common/rect.h
index 569b530a..d109cc97 100644
--- a/common/rect.h
+++ b/common/rect.h
@@ -23,7 +23,7 @@
 #define MIN(x, y) (((x) <= (y)) ? (x) : (y))
 #define MAX(x, y) (((x) >= (y)) ? (x) : (y))
 
-static inline void rect_sect(Rect* r, const Rect* bounds)
+static inline void rect_sect(SpiceRect* r, const SpiceRect* bounds)
 {
     r->left = MAX(r->left, bounds->left);
     r->right = MIN(r->right, bounds->right);
@@ -34,7 +34,7 @@ static inline void rect_sect(Rect* r, const Rect* bounds)
     r->bottom = MAX(r->top, r->bottom);
 }
 
-static inline void rect_offset(Rect* r, int dx, int dy)
+static inline void rect_offset(SpiceRect* r, int dx, int dy)
 {
     r->left += dx;
     r->right += dx;
@@ -42,24 +42,24 @@ static inline void rect_offset(Rect* r, int dx, int dy)
     r->bottom += dy;
 }
 
-static inline int rect_is_empty(const Rect* r)
+static inline int rect_is_empty(const SpiceRect* r)
 {
     return r->top == r->bottom || r->left == r->right;
 }
 
-static inline int rect_intersects(const Rect* r1, const Rect* r2)
+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 Rect *r1, const Rect *r2)
+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(Rect *dest, const Rect *r)
+static inline void rect_union(SpiceRect *dest, const SpiceRect *r)
 {
     dest->top = MIN(dest->top, r->top);
     dest->left = MIN(dest->left, r->left);
@@ -67,7 +67,7 @@ static inline void rect_union(Rect *dest, const Rect *r)
     dest->right = MAX(dest->right, r->right);
 }
 
-static inline int rect_is_same_size(const Rect *r1, const Rect *r2)
+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;
@@ -75,37 +75,37 @@ static inline int rect_is_same_size(const Rect *r1, const Rect *r2)
 
 #ifdef __cplusplus
 
-static inline void rect_sect(Rect& r, const Rect& bounds)
+static inline void rect_sect(SpiceRect& r, const SpiceRect& bounds)
 {
     rect_sect(&r, &bounds);
 }
 
-static inline void rect_offset(Rect& r, int dx, int dy)
+static inline void rect_offset(SpiceRect& r, int dx, int dy)
 {
     rect_offset(&r, dx, dy);
 }
 
-static inline int rect_is_empty(const Rect& r)
+static inline int rect_is_empty(const SpiceRect& r)
 {
     return rect_is_empty(&r);
 }
 
-static inline int rect_intersects(const Rect& r1, const Rect& r2)
+static inline int rect_intersects(const SpiceRect& r1, const SpiceRect& r2)
 {
     return rect_intersects(&r1, &r2);
 }
 
-static inline int rect_is_equal(const Rect& r1, const Rect& r2)
+static inline int rect_is_equal(const SpiceRect& r1, const SpiceRect& r2)
 {
     return rect_is_equal(&r1, &r2);
 }
 
-static inline void rect_union(Rect& dest, const Rect& r)
+static inline void rect_union(SpiceRect& dest, const SpiceRect& r)
 {
     rect_union(&dest, &r);
 }
 
-static inline int rect_is_same_size(const Rect& r1, const Rect& r2)
+static inline int rect_is_same_size(const SpiceRect& r1, const SpiceRect& r2)
 {
     return rect_is_same_size(&r1, &r2);
 }
diff --git a/common/region.c b/common/region.c
index d1d7f4a0..f0bb614f 100644
--- a/common/region.c
+++ b/common/region.c
@@ -42,7 +42,7 @@
 #define REGION_IS_VALID(region) TRUE
 #endif
 
-static int rect_is_valid(const Rect *r)
+static int rect_is_valid(const SpiceRect *r)
 {
     if (r->top > r->bottom || r->left > r->right) {
         printf("%s: invalid rect\n", __FUNCTION__);
@@ -52,7 +52,7 @@ static int rect_is_valid(const Rect *r)
 }
 
 #ifdef REGION_TEST
-static void rect_set(Rect *r, int32_t top, int32_t left, int32_t bottom, int32_t right)
+static void rect_set(SpiceRect *r, int32_t top, int32_t left, int32_t bottom, int32_t right)
 {
     r->top = top;
     r->left = left;
@@ -97,10 +97,10 @@ void region_clone(QRegion *dest, const QRegion *src)
         dest->rects = dest->buf;
         dest->rects_size = RECTS_BUF_SIZE;
     } else {
-        dest->rects = (Rect *)malloc(sizeof(Rect) * dest->num_rects);
+        dest->rects = (SpiceRect *)malloc(sizeof(SpiceRect) * dest->num_rects);
         dest->rects_size = dest->num_rects;
     }
-    memcpy(dest->rects, src->rects, dest->num_rects * sizeof(Rect));
+    memcpy(dest->rects, src->rects, dest->num_rects * sizeof(SpiceRect));
     ASSERT(REGION_IS_VALID(src));
     ASSERT(REGION_IS_VALID(dest));
 }
@@ -109,7 +109,7 @@ int region_is_valid(const QRegion *rgn)
 {
     if (rgn->num_rects) {
         uint32_t i;
-        Rect bbox;
+        SpiceRect bbox;
 
         if (!rect_is_valid(&rgn->bbox)) {
             return FALSE;
@@ -119,14 +119,14 @@ int region_is_valid(const QRegion *rgn)
             return FALSE;
         }
         for (i = 1; i < rgn->num_rects; i++) {
-            Rect *r;
+            SpiceRect *r;
 
             r = &rgn->rects[i];
             if (!rect_is_valid(r) || rect_is_empty(r)) {
                 return FALSE;
             }
 
-            Rect *priv = r - 1;
+            SpiceRect *priv = r - 1;
             if (r->top < priv->top) {
                 return FALSE;
             } else if (r->top == priv->top) {
@@ -249,11 +249,11 @@ int region_is_equal(const QRegion *rgn1, const QRegion *rgn2)
 #endif
 
 typedef struct RgnOpCtx {
-    Rect *now;
-    Rect *end;
-    Rect *scan_line;
-    Rect r;
-    Rect split;
+    SpiceRect *now;
+    SpiceRect *end;
+    SpiceRect *scan_line;
+    SpiceRect r;
+    SpiceRect split;
 #ifdef REGION_USE_IMPROVED
     int abort;
 #endif
@@ -266,8 +266,8 @@ static inline int op_ctx_is_valid(RgnOpCtx *ctx)
 
 static void op_context_next(RgnOpCtx *ctx)
 {
-    Rect *now;
-    Rect *next;
+    SpiceRect *now;
+    SpiceRect *next;
 
     ASSERT(op_ctx_is_valid(ctx));
     now = ctx->now;
@@ -298,7 +298,7 @@ static void op_context_next(RgnOpCtx *ctx)
     ctx->now = next;
 }
 
-static void op_context_init(RgnOpCtx *ctx, uint32_t num_rects, Rect *rects)
+static void op_context_init(RgnOpCtx *ctx, uint32_t num_rects, SpiceRect *rects)
 {
     ctx->scan_line = ctx->now = rects;
     ctx->end = ctx->now + num_rects;
@@ -334,17 +334,17 @@ static inline void op_ctx_split(RgnOpCtx *ctx, int32_t h_line)
     ctx->r.bottom = h_line;
 }
 
-static void region_steal_rects(QRegion *rgn, uint32_t *num_rects, Rect **rects)
+static void region_steal_rects(QRegion *rgn, uint32_t *num_rects, SpiceRect **rects)
 {
     ASSERT(REGION_IS_VALID(rgn));
     if ((*num_rects = rgn->num_rects)) {
         if (rgn->rects == rgn->buf) {
-            *rects = (Rect *)malloc(sizeof(Rect) * rgn->num_rects);
-            memcpy(*rects, rgn->rects, sizeof(Rect) * rgn->num_rects);
+            *rects = (SpiceRect *)malloc(sizeof(SpiceRect) * rgn->num_rects);
+            memcpy(*rects, rgn->rects, sizeof(SpiceRect) * rgn->num_rects);
         } else {
             *rects = rgn->rects;
 #ifdef ALLOC_ON_STEAL
-            rgn->rects = (Rect *)malloc(sizeof(Rect) * rgn->num_rects);
+            rgn->rects = (SpiceRect *)malloc(sizeof(SpiceRect) * rgn->num_rects);
             rgn->rects_size = rgn->num_rects;
             rgn->num_rects = 0;
             return;
@@ -359,14 +359,14 @@ static void region_steal_rects(QRegion *rgn, uint32_t *num_rects, Rect **rects)
 
 typedef struct JoinContext {
     QRegion *rgn;
-    Rect *line0;
-    Rect *line1;
-    Rect *end;
+    SpiceRect *line0;
+    SpiceRect *line1;
+    SpiceRect *end;
 } JoinContext;
 
-static inline Rect *__get_line(QRegion *rgn, Rect *pos)
+static inline SpiceRect *__get_line(QRegion *rgn, SpiceRect *pos)
 {
-    Rect *end = rgn->rects + rgn->num_rects;
+    SpiceRect *end = rgn->rects + rgn->num_rects;
 
     if (pos < end) {
         int32_t line_top = pos->top;
@@ -394,8 +394,8 @@ static inline int region_join_next(JoinContext *context)
 
 static inline void region_join_join(JoinContext *context)
 {
-    Rect *pos_0 = context->line0;
-    Rect *pos_1 = context->line1;
+    SpiceRect *pos_0 = context->line0;
+    SpiceRect *pos_1 = context->line1;
     int32_t bottom;
     QRegion *rgn;
 
@@ -441,7 +441,7 @@ static inline void region_join(QRegion *rgn)
     ASSERT(REGION_IS_VALID(rgn));
 }
 
-static void region_push_rect(QRegion *rgn, Rect *r)
+static void region_push_rect(QRegion *rgn, SpiceRect *r)
 {
     ASSERT(REGION_IS_VALID(rgn));
     ASSERT(rect_is_valid(r));
@@ -450,7 +450,7 @@ static void region_push_rect(QRegion *rgn, Rect *r)
         rgn->rects[0] = rgn->bbox = *r;
         return;
     } else {
-        Rect *priv = &rgn->rects[rgn->num_rects - 1];
+        SpiceRect *priv = &rgn->rects[rgn->num_rects - 1];
 
         if (priv->top == r->top && priv->right == r->left) {
             ASSERT(priv->bottom == r->bottom);
@@ -459,10 +459,10 @@ static void region_push_rect(QRegion *rgn, Rect *r)
             return;
         }
         if (rgn->rects_size == rgn->num_rects) {
-            Rect *old = rgn->rects;
+            SpiceRect *old = rgn->rects;
             rgn->rects_size = rgn->rects_size * 2;
-            rgn->rects = (Rect *)malloc(sizeof(Rect) * rgn->rects_size);
-            memcpy(rgn->rects, old, sizeof(Rect) * rgn->num_rects);
+            rgn->rects = (SpiceRect *)malloc(sizeof(SpiceRect) * rgn->rects_size);
+            memcpy(rgn->rects, old, sizeof(SpiceRect) * rgn->num_rects);
             if (old != rgn->buf) {
                 free(old);
             }
@@ -474,10 +474,10 @@ static void region_push_rect(QRegion *rgn, Rect *r)
 
 #ifdef REGION_USE_IMPROVED
 
-static Rect *op_context_find_area_below(RgnOpCtx *ctx, int32_t val)
+static SpiceRect *op_context_find_area_below(RgnOpCtx *ctx, int32_t val)
 {
-    Rect *start = ctx->now;
-    Rect *end = ctx->end;
+    SpiceRect *start = ctx->now;
+    SpiceRect *end = ctx->end;
 
     while (start != end) {
         int pos = (end - start) / 2;
@@ -492,7 +492,7 @@ static Rect *op_context_find_area_below(RgnOpCtx *ctx, int32_t val)
 
 static int op_context_skip_v(RgnOpCtx *ctx, int32_t top)
 {
-    Rect *end = op_context_find_area_below(ctx, top);
+    SpiceRect *end = op_context_find_area_below(ctx, top);
     if (end != ctx->now) {
         ctx->now = ctx->scan_line = end;
         if (ctx->now == ctx->end) {
@@ -505,13 +505,13 @@ static int op_context_skip_v(RgnOpCtx *ctx, int32_t top)
     return FALSE;
 }
 
-typedef void (*op_callback_t)(RgnOpCtx *context, Rect *, Rect *);
+typedef void (*op_callback_t)(RgnOpCtx *context, SpiceRect *, SpiceRect *);
 
 static void op_context_skip(RgnOpCtx *self, RgnOpCtx *other, op_callback_t on_self,
                             op_callback_t on_other)
 {
-    Rect *save1 = self->now;
-    Rect *save2 = other->now;
+    SpiceRect *save1 = self->now;
+    SpiceRect *save2 = other->now;
     int more;
     do {
         op_context_skip_v(self, other->r.top);
@@ -606,7 +606,7 @@ typedef struct SelfOpCtx {
     QRegion *rgn;
 } SelfOpCtx;
 
-static void add_rects(RgnOpCtx *ctx, Rect *now, Rect *end)
+static void add_rects(RgnOpCtx *ctx, SpiceRect *now, SpiceRect *end)
 {
     SelfOpCtx *self_ctx = (SelfOpCtx *)ctx;
     for (; now < end; now++) {
@@ -620,7 +620,7 @@ static void region_op(QRegion *rgn, const QRegion *other_rgn, op_callback_t on_s
     SelfOpCtx self;
     RgnOpCtx other;
     uint32_t num_rects;
-    Rect *rects;
+    SpiceRect *rects;
 
     region_steal_rects(rgn, &num_rects, &rects);
     op_context_init(&self.ctx, num_rects, rects);
@@ -665,7 +665,7 @@ typedef struct TestOpCtx {
 } TestOpCtx;
 
 
-static void region_test_on_self(RgnOpCtx *ctx, Rect *now, Rect *end)
+static void region_test_on_self(RgnOpCtx *ctx, SpiceRect *now, SpiceRect *end)
 {
     TestOpCtx *test_ctx = (TestOpCtx *)ctx;
     test_ctx->result |= REGION_TEST_LEFT_EXCLUSIVE;
@@ -675,7 +675,7 @@ static void region_test_on_self(RgnOpCtx *ctx, Rect *now, Rect *end)
     }
 }
 
-static void region_test_on_other(RgnOpCtx *ctx, Rect *now, Rect *end)
+static void region_test_on_other(RgnOpCtx *ctx, SpiceRect *now, SpiceRect *end)
 {
     TestOpCtx *test_ctx = (TestOpCtx *)ctx;
     test_ctx->result |= REGION_TEST_RIGHT_EXCLUSIVE;
@@ -685,7 +685,7 @@ static void region_test_on_other(RgnOpCtx *ctx, Rect *now, Rect *end)
     }
 }
 
-static void region_test_on_both(RgnOpCtx *ctx, Rect *now, Rect *end)
+static void region_test_on_both(RgnOpCtx *ctx, SpiceRect *now, SpiceRect *end)
 {
     TestOpCtx *test_ctx = (TestOpCtx *)ctx;
     test_ctx->result |= REGION_TEST_SHARED;
@@ -715,7 +715,7 @@ int region_test(const QRegion *rgn, const QRegion *other_rgn, int query)
 #define RIGION_OP_ADD_OTHER (1 << 1)
 #define RIGION_OP_ADD_COMMON (1 << 2)
 
-static inline void region_on_self(QRegion *rgn, Rect *r, uint32_t op)
+static inline void region_on_self(QRegion *rgn, SpiceRect *r, uint32_t op)
 {
     ASSERT(REGION_IS_VALID(rgn));
     if (op & RIGION_OP_ADD_SELF) {
@@ -723,7 +723,7 @@ static inline void region_on_self(QRegion *rgn, Rect *r, uint32_t op)
     }
 }
 
-static inline void region_on_other(QRegion *rgn, Rect *r, uint32_t op)
+static inline void region_on_other(QRegion *rgn, SpiceRect *r, uint32_t op)
 {
     ASSERT(REGION_IS_VALID(rgn));
     if (op & RIGION_OP_ADD_OTHER) {
@@ -731,7 +731,7 @@ static inline void region_on_other(QRegion *rgn, Rect *r, uint32_t op)
     }
 }
 
-static inline void region_on_both(QRegion *rgn, Rect *r, uint32_t op)
+static inline void region_on_both(QRegion *rgn, SpiceRect *r, uint32_t op)
 {
     ASSERT(REGION_IS_VALID(rgn));
     if (op & RIGION_OP_ADD_COMMON) {
@@ -744,7 +744,7 @@ static void region_op(QRegion *rgn, const QRegion *other_rgn, uint32_t op)
     RgnOpCtx self;
     RgnOpCtx other;
     uint32_t num_rects;
-    Rect *rects;
+    SpiceRect *rects;
 
     ASSERT(REGION_IS_VALID(rgn));
     ASSERT(REGION_IS_VALID(other_rgn));
@@ -809,8 +809,8 @@ void region_exclude(QRegion *rgn, const QRegion *other_rgn)
 
 void region_offset(QRegion *rgn, int32_t dx, int32_t dy)
 {
-    Rect *now;
-    Rect *end;
+    SpiceRect *now;
+    SpiceRect *end;
     ASSERT(REGION_IS_VALID(rgn));
     if (region_is_empty(rgn)) {
         return;
@@ -823,7 +823,7 @@ void region_offset(QRegion *rgn, int32_t dx, int32_t dy)
     }
 }
 
-void region_add(QRegion *rgn, const Rect *r)
+void region_add(QRegion *rgn, const SpiceRect *r)
 {
     ASSERT(REGION_IS_VALID(rgn));
     ASSERT(rect_is_valid(r));
@@ -842,7 +842,7 @@ void region_add(QRegion *rgn, const Rect *r)
     }
 }
 
-void region_remove(QRegion *rgn, const Rect *r)
+void region_remove(QRegion *rgn, const SpiceRect *r)
 {
     ASSERT(REGION_IS_VALID(rgn));
     ASSERT(rect_is_valid(r));
@@ -934,7 +934,7 @@ int region_contains_point(const QRegion *rgn, int32_t x, int32_t y)
     if (region_is_empty(rgn)) {
         return FALSE;
     }
-    Rect point;
+    SpiceRect point;
     point.left = x;
     point.right = point.left + 1;
     point.top = y;
@@ -944,8 +944,8 @@ int region_contains_point(const QRegion *rgn, int32_t x, int32_t y)
         return FALSE;
     }
 
-    Rect* now = rgn->rects;
-    Rect* end = now + rgn->num_rects;
+    SpiceRect* now = rgn->rects;
+    SpiceRect* end = now + rgn->num_rects;
 
     for (; now < end; now++) {
         if (rect_intersects(now, &point)) {
@@ -990,8 +990,8 @@ int main(void)
     QRegion *r1 = &_r1;
     QRegion *r2 = &_r2;
     QRegion *r3 = &_r3;
-    Rect _r;
-    Rect *r = &_r;
+    SpiceRect _r;
+    SpiceRect *r = &_r;
     int expected[5];
 
     region_init(r1);
diff --git a/common/region.h b/common/region.h
index 29a58223..73f8ed9d 100644
--- a/common/region.h
+++ b/common/region.h
@@ -27,10 +27,10 @@
 
 typedef struct QRegion {
     uint32_t num_rects;
-    Rect bbox;
-    Rect *rects;
+    SpiceRect bbox;
+    SpiceRect *rects;
     uint32_t rects_size;
-    Rect buf[RECTS_BUF_SIZE];
+    SpiceRect buf[RECTS_BUF_SIZE];
 } QRegion;
 
 #ifdef REGION_USE_IMPROVED
@@ -64,8 +64,8 @@ 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 Rect *r);
-void region_remove(QRegion *rgn, const Rect *r);
+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);
 
diff --git a/common/rop3.c b/common/rop3.c
index 08f9cad3..6d2efa2b 100644
--- a/common/rop3.c
+++ b/common/rop3.c
@@ -24,11 +24,11 @@
 #endif
 
 typedef void (*rop3_with_pattern_handler_t)(cairo_surface_t *d, cairo_surface_t *s,
-                                            Point *src_pos, cairo_surface_t *p,
-                                            Point *pat_pos);
+                                            SpicePoint *src_pos, cairo_surface_t *p,
+                                            SpicePoint *pat_pos);
 
 typedef void (*rop3_with_color_handler_t)(cairo_surface_t *d, cairo_surface_t *s,
-                                          Point *src_pos, uint32_t rgb);
+                                          SpicePoint *src_pos, uint32_t rgb);
 
 typedef void (*rop3_test_handler_t)();
 
@@ -40,13 +40,13 @@ static rop3_test_handler_t rop3_test_handlers[ROP3_NUM_OPS];
 
 
 static void default_rop3_with_pattern_handler(cairo_surface_t *d, cairo_surface_t *s,
-                                              Point *src_pos, cairo_surface_t *p,
-                                              Point *pat_pos)
+                                              SpicePoint *src_pos, cairo_surface_t *p,
+                                              SpicePoint *pat_pos)
 {
     WARN("not implemented 0x%x");
 }
 
-static void default_rop3_withe_color_handler(cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+static void default_rop3_withe_color_handler(cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,
                                              uint32_t rgb)
 {
     WARN("not implemented 0x%x");
@@ -57,8 +57,8 @@ static void default_rop3_test_handler()
 }
 
 #define ROP3_HANDLERS(name, formula, index)                                                     \
-static void rop3_handle_p_##name(cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,        \
-                                      cairo_surface_t *p, Point *pat_pos)                       \
+static void rop3_handle_p_##name(cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,        \
+                                      cairo_surface_t *p, SpicePoint *pat_pos)                       \
 {                                                                                               \
     int width = cairo_image_surface_get_width(d);                                               \
     int height = cairo_image_surface_get_height(d);                                             \
@@ -94,7 +94,7 @@ static void rop3_handle_p_##name(cairo_surface_t *d, cairo_surface_t *s, Point *
     }                                                                                           \
 }                                                                                               \
                                                                                                 \
-static void rop3_handle_c_##name(cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,        \
+static void rop3_handle_c_##name(cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,        \
                                    uint32_t rgb)                                                \
 {                                                                                               \
     int width = cairo_image_surface_get_width(d);                                               \
@@ -599,13 +599,13 @@ void rop3_init()
     }
 }
 
-void do_rop3_with_pattern(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
-                          cairo_surface_t *p, Point *pat_pos)
+void do_rop3_with_pattern(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,
+                          cairo_surface_t *p, SpicePoint *pat_pos)
 {
     rop3_with_pattern_handlers[rop3](d, s, src_pos, p, pat_pos);
 }
 
-void do_rop3_with_color(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+void do_rop3_with_color(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,
                         uint32_t rgb)
 {
     rop3_with_color_handlers[rop3](d, s, src_pos, rgb);
diff --git a/common/rop3.h b/common/rop3.h
index fcf86423..31cbcdaa 100644
--- a/common/rop3.h
+++ b/common/rop3.h
@@ -23,9 +23,9 @@
 #include "draw.h"
 #include "cairo.h"
 
-void do_rop3_with_pattern(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
-                          cairo_surface_t *p, Point *pat_pos);
-void do_rop3_with_color(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+void do_rop3_with_pattern(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,
+                          cairo_surface_t *p, SpicePoint *pat_pos);
+void do_rop3_with_color(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, SpicePoint *src_pos,
                         uint32_t rgb);
 
 void rop3_init();
diff --git a/server/red_channel.c b/server/red_channel.c
index 48ace448..d8ea49dc 100644
--- a/server/red_channel.c
+++ b/server/red_channel.c
@@ -72,17 +72,17 @@ static void red_peer_handle_incoming(RedsStreamContext *peer, IncomingHandler *h
 
     for (;;) {
         int ret_handle;
-        if (handler->header_pos < sizeof(RedDataHeader)) {
+        if (handler->header_pos < sizeof(SpiceDataHeader)) {
             bytes_read = red_peer_receive(peer,
                                           ((uint8_t *)&handler->header) + handler->header_pos,
-                                          sizeof(RedDataHeader) - handler->header_pos);
+                                          sizeof(SpiceDataHeader) - handler->header_pos);
             if (bytes_read == -1) {
                 handler->on_error(handler->opaque);
                 return;
             }
             handler->header_pos += bytes_read;
 
-            if (handler->header_pos != sizeof(RedDataHeader)) {
+            if (handler->header_pos != sizeof(SpiceDataHeader)) {
                 return;
             }
         }
@@ -328,17 +328,17 @@ void red_channel_init_outgoing_messages_window(RedChannel *channel)
     red_channel_push(channel);
 }
 
-int red_channel_handle_message(RedChannel *channel, RedDataHeader *header, uint8_t *msg)
+int red_channel_handle_message(RedChannel *channel, SpiceDataHeader *header, uint8_t *msg)
 {
     switch (header->type) {
-    case REDC_ACK_SYNC:
+    case SPICE_MSGC_ACK_SYNC:
         if (header->size != sizeof(uint32_t)) {
             red_printf("bad message size");
             return FALSE;
         }
         channel->ack_data.client_generation = *(uint32_t *)(msg);
         break;
-    case REDC_ACK:
+    case SPICE_MSGC_ACK:
         if (channel->ack_data.client_generation == channel->ack_data.generation) {
             channel->ack_data.messages_window -= CLIENT_ACK_WINDOW;
             red_channel_push(channel);
@@ -377,7 +377,7 @@ void red_channel_reset_send_data(RedChannel *channel)
     channel->send_data.header.size = 0;
     channel->send_data.header.sub_list = 0;
     ++channel->send_data.header.serial;
-    __red_channel_add_buf(channel, (void *)&channel->send_data.header, sizeof(RedDataHeader));
+    __red_channel_add_buf(channel, (void *)&channel->send_data.header, sizeof(SpiceDataHeader));
 }
 
 void red_channel_init_send_data(RedChannel *channel, uint16_t msg_type, PipeItem *item)
@@ -408,7 +408,7 @@ static void red_channel_send(RedChannel *channel)
 
 void red_channel_begin_send_massage(RedChannel *channel)
 {
-    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->send_data.size = channel->send_data.header.size + sizeof(SpiceDataHeader);
     channel->ack_data.messages_window++;
     red_channel_send(channel);
 }
diff --git a/server/red_channel.h b/server/red_channel.h
index 1096ba70..8c8518c4 100644
--- a/server/red_channel.h
+++ b/server/red_channel.h
@@ -36,15 +36,15 @@
    At the final stage, this interface shouldn't be exposed. Only RedChannel will use it. */
 
 typedef int (*handle_message_proc)(void *opaque,
-                                   RedDataHeader *header, uint8_t *msg);
-typedef uint8_t *(*alloc_msg_recv_buf_proc)(void *opaque, RedDataHeader *msg_header);
+                                   SpiceDataHeader *header, uint8_t *msg);
+typedef uint8_t *(*alloc_msg_recv_buf_proc)(void *opaque, SpiceDataHeader *msg_header);
 typedef void (*release_msg_recv_buf_proc)(void *opaque,
-                                          RedDataHeader *msg_header, uint8_t *msg);
+                                          SpiceDataHeader *msg_header, uint8_t *msg);
 typedef void (*on_incoming_error_proc)(void *opaque);
 
 typedef struct IncomingHandler {
     void *opaque;
-    RedDataHeader header;
+    SpiceDataHeader header;
     uint32_t header_pos;
     uint8_t *msg; // data of the msg following the header. allocated by alloc_msg_buf.
     uint32_t msg_pos;
@@ -88,11 +88,11 @@ typedef struct PipeItem {
 typedef struct RedChannel RedChannel;
 
 typedef uint8_t *(*channel_alloc_msg_recv_buf_proc)(RedChannel *channel,
-                                                    RedDataHeader *msg_header);
+                                                    SpiceDataHeader *msg_header);
 typedef int (*channel_handle_message_proc)(RedChannel *channel,
-                                           RedDataHeader *header, uint8_t *msg);
+                                           SpiceDataHeader *header, uint8_t *msg);
 typedef void (*channel_release_msg_recv_buf_proc)(RedChannel *channel,
-                                                  RedDataHeader *msg_header, uint8_t *msg);
+                                                  SpiceDataHeader *msg_header, uint8_t *msg);
 typedef void (*channel_disconnect_proc)(RedChannel *channel);
 typedef int (*channel_configure_socket_proc)(RedChannel *channel);
 typedef void (*channel_send_pipe_item_proc)(RedChannel *channel, PipeItem *item);
@@ -115,10 +115,10 @@ struct RedChannel {
     uint32_t pipe_size;
 
     struct {
-        RedDataHeader header;
+        SpiceDataHeader header;
         union {
-            RedSetAck ack;
-            RedMigrate migrate;
+            SpiceMsgSetAck ack;
+            SpiceMsgMigrate migrate;
         } u;
         uint32_t n_bufs;
         BufDescriptor bufs[MAX_SEND_BUFS];
@@ -158,7 +158,7 @@ void red_channel_shutdown(RedChannel *channel);
 void red_channel_init_outgoing_messages_window(RedChannel *channel);
 
 /* handles general channel msgs from the client */
-int red_channel_handle_message(RedChannel *channel, RedDataHeader *header, uint8_t *msg);
+int red_channel_handle_message(RedChannel *channel, SpiceDataHeader *header, uint8_t *msg);
 
 /* when preparing send_data: should call reset, then init and then add_buf per buffer that is
    being sent */
diff --git a/server/red_client_cache.h b/server/red_client_cache.h
index c7b40e2f..3db0ce9c 100644
--- a/server/red_client_cache.h
+++ b/server/red_client_cache.h
@@ -20,7 +20,7 @@
 #define CACHE_NAME cursor_cache
 #define CACHE_HASH_KEY CURSOR_CACHE_HASH_KEY
 #define CACHE_HASH_SIZE CURSOR_CACHE_HASH_SIZE
-#define CACHE_INVAL_TYPE RED_CURSOR_INVAL_ONE
+#define CACHE_INVAL_TYPE SPICE_MSG_CURSOR_INVAL_ONE
 #define FUNC_NAME(name) red_cursor_cache_##name
 #define VAR_NAME(name) cursor_cache_##name
 #define CHANNEL CursorChannel
@@ -30,7 +30,7 @@
 #define CACHE_NAME palette_cache
 #define CACHE_HASH_KEY PALETTE_CACHE_HASH_KEY
 #define CACHE_HASH_SIZE PALETTE_CACHE_HASH_SIZE
-#define CACHE_INVAL_TYPE RED_DISPLAY_INVAL_PALETTE
+#define CACHE_INVAL_TYPE SPICE_MSG_DISPLAY_INVAL_PALETTE
 #define FUNC_NAME(name) red_palette_cache_##name
 #define VAR_NAME(name) palette_cache_##name
 #define CHANNEL DisplayChannel
diff --git a/server/red_client_shared_cache.h b/server/red_client_shared_cache.h
index 1d3c4528..141f1b11 100644
--- a/server/red_client_shared_cache.h
+++ b/server/red_client_shared_cache.h
@@ -27,7 +27,7 @@
 #define PRIVATE_FUNC_NAME(name) __pixmap_cache_##name
 #define CHANNEL DisplayChannel
 #define CACH_GENERATION pixmap_cache_generation
-#define INVAL_ALL_VERB RED_DISPLAY_INVAL_ALL_PIXMAPS
+#define INVAL_ALL_VERB SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS
 #else
 
 #error "no cache type."
@@ -112,7 +112,7 @@ static int FUNC_NAME(add)(CACHE *cache, uint64_t id, uint32_t size, CHANNEL *cha
         cache->items--;
         cache->available += tail->size;
         cache->sync[channel->base.id] = serial;
-        display_channel_push_release(channel, RED_RES_TYPE_PIXMAP, tail->id, tail->sync);
+        display_channel_push_release(channel, SPICE_RES_TYPE_PIXMAP, tail->id, tail->sync);
         free(tail);
     }
     ++cache->items;
@@ -149,7 +149,7 @@ static void PRIVATE_FUNC_NAME(clear)(CACHE *cache)
     cache->items = 0;
 }
 
-static void FUNC_NAME(reset)(CACHE *cache, CHANNEL *channel, RedWaitForChannels* sync_data)
+static void FUNC_NAME(reset)(CACHE *cache, CHANNEL *channel, SpiceMsgWaitForChannels* sync_data)
 {
     uint8_t wait_count;
     uint64_t serial;
@@ -167,7 +167,7 @@ static void FUNC_NAME(reset)(CACHE *cache, CHANNEL *channel, RedWaitForChannels*
     wait_count = 0;
     for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
         if (cache->sync[i] && i != channel->base.id) {
-            sync_data->wait_list[wait_count].channel_type = RED_CHANNEL_DISPLAY;
+            sync_data->wait_list[wait_count].channel_type = SPICE_CHANNEL_DISPLAY;
             sync_data->wait_list[wait_count].channel_id = i;
             sync_data->wait_list[wait_count++].message_serial = cache->sync[i];
         }
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index e35aba35..d829805e 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -543,7 +543,7 @@ RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface)
         red_error("reds channel malloc failed");
     }
     memset(reds_channel, 0, sizeof(Channel));
-    reds_channel->type = RED_CHANNEL_DISPLAY;
+    reds_channel->type = SPICE_CHANNEL_DISPLAY;
     reds_channel->id = qxl_interface->base.id;
     reds_channel->link = red_dispatcher_set_peer;
     reds_channel->shutdown = red_dispatcher_shutdown_peer;
@@ -555,7 +555,7 @@ RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface)
         red_error("reds channel malloc failed");
     }
     memset(cursor_channel, 0, sizeof(Channel));
-    cursor_channel->type = RED_CHANNEL_CURSOR;
+    cursor_channel->type = SPICE_CHANNEL_CURSOR;
     cursor_channel->id = qxl_interface->base.id;
     cursor_channel->link = red_dispatcher_set_cursor_peer;
     cursor_channel->shutdown = red_dispatcher_shutdown_cursor_peer;
diff --git a/server/red_tunnel_worker.c b/server/red_tunnel_worker.c
index e4cb2172..a2a4eca2 100644
--- a/server/red_tunnel_worker.c
+++ b/server/red_tunnel_worker.c
@@ -115,8 +115,8 @@ typedef struct RedSocketRawSndBuf {
 /* data received from the client */
 typedef struct RedSocketRawRcvBuf {
     RawTunneledBuffer base;
-    uint8_t buf[MAX_SOCKET_DATA_SIZE + sizeof(RedcTunnelSocketData)];
-    RedcTunnelSocketData *msg_info;
+    uint8_t buf[MAX_SOCKET_DATA_SIZE + sizeof(SpiceMsgcTunnelSocketData)];
+    SpiceMsgcTunnelSocketData *msg_info;
 } RedSocketRawRcvBuf;
 
 typedef struct ReadyTunneledChunk ReadyTunneledChunk;
@@ -276,7 +276,7 @@ struct RedSocket {
     uint32_t mig_client_status_msg;         // the last status change msg that was received from
                                             //the client during migration, and thus was unhandled.
                                             // It is 0 if the status didn't change during migration
-    uint32_t mig_open_ack_tokens;           // if REDC_TUNNEL_SOCKET_OPEN_ACK was received during
+    uint32_t mig_open_ack_tokens;           // if SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK was received during
                                             // migration, we store the tokens we received in the
                                             // msg.
 };
@@ -492,14 +492,14 @@ struct TunnelChannel {
 
     struct {
         union {
-            RedTunnelInit init;
-            RedTunnelServiceIpMap service_ip;
-            RedTunnelSocketOpen socket_open;
-            RedTunnelSocketFin socket_fin;
-            RedTunnelSocketClose socket_close;
-            RedTunnelSocketClosedAck socket_close_ack;
-            RedTunnelSocketData socket_data;
-            RedTunnelSocketTokens socket_token;
+            SpiceMsgTunnelInit init;
+            SpiceMsgTunnelServiceIpMap service_ip;
+            SpiceMsgTunnelSocketOpen socket_open;
+            SpiceMsgTunnelSocketFin socket_fin;
+            SpiceMsgTunnelSocketClose socket_close;
+            SpiceMsgTunnelSocketClosedAck socket_close_ack;
+            SpiceMsgTunnelSocketData socket_data;
+            SpiceMsgTunnelSocketTokens socket_token;
             TunnelMigrateData migrate_data;
         } u;
     } send_data;
@@ -712,7 +712,7 @@ static inline RedSocketRawRcvBuf *__tunnel_worker_alloc_socket_rcv_buf(TunnelWor
             red_error("malloc of send buf failed");
         }
     }
-    ret->msg_info = (RedcTunnelSocketData *)ret->buf;
+    ret->msg_info = (SpiceMsgcTunnelSocketData *)ret->buf;
     ret->base.usr_opaque = NULL;
     ret->base.data = ret->msg_info->data;
     ret->base.size = 0;
@@ -953,7 +953,7 @@ static TunneledBufferProcessQueue *tunnel_socket_alloc_simple_print_request_proc
                                                                                  RedSocket *sckt)
 {
     return __tunnel_socket_alloc_simple_process_queue(sckt,
-                                                      RED_TUNNEL_SERVICE_TYPE_IPP,
+                                                      SPICE_TUNNEL_SERVICE_TYPE_IPP,
                                                       PROCESS_DIRECTION_TYPE_REQUEST);
 }
 
@@ -961,7 +961,7 @@ static TunneledBufferProcessQueue *tunnel_socket_alloc_simple_print_reply_proces
                                                                                   RedSocket *sckt)
 {
     return __tunnel_socket_alloc_simple_process_queue(sckt,
-                                                      RED_TUNNEL_SERVICE_TYPE_IPP,
+                                                      SPICE_TUNNEL_SERVICE_TYPE_IPP,
                                                       PROCESS_DIRECTION_TYPE_REPLY);
 }
 
@@ -1015,7 +1015,7 @@ void *red_tunnel_attach(CoreInterface *core_interface, NetWireInterface *vlan_in
 
     worker->null_interface.worker = worker;
 
-    worker->channel_interface.type = RED_CHANNEL_TUNNEL;
+    worker->channel_interface.type = SPICE_CHANNEL_TUNNEL;
     worker->channel_interface.id = 0;
     worker->channel_interface.link = handle_tunnel_channel_link;
     worker->channel_interface.shutdown = handle_tunnel_channel_shutdown;
@@ -1110,7 +1110,7 @@ static inline TunnelService *__tunnel_worker_add_service(TunnelWorker *worker, u
 }
 
 static TunnelService *tunnel_worker_add_service(TunnelWorker *worker, uint32_t size,
-                                                RedcTunnelAddGenericService *redc_service)
+                                                SpiceMsgcTunnelAddGenericService *redc_service)
 {
     return __tunnel_worker_add_service(worker, size, redc_service->type,
                                        redc_service->id, redc_service->group,
@@ -1136,7 +1136,7 @@ static void tunnel_worker_free_print_service(TunnelWorker *worker, TunnelPrintSe
 }
 
 static TunnelPrintService *tunnel_worker_add_print_service(TunnelWorker *worker,
-                                                           RedcTunnelAddPrintService *redc_service)
+                                                           SpiceMsgcTunnelAddPrintService *redc_service)
 {
     TunnelPrintService *service;
 
@@ -1147,8 +1147,8 @@ static TunnelPrintService *tunnel_worker_add_print_service(TunnelWorker *worker,
         return NULL;
     }
 
-    if (redc_service->ip.type == RED_TUNNEL_IP_TYPE_IPv4) {
-        memcpy(service->ip, redc_service->ip.data, sizeof(RedTunnelIPv4));
+    if (redc_service->ip.type == SPICE_TUNNEL_IP_TYPE_IPv4) {
+        memcpy(service->ip, redc_service->ip.data, sizeof(SpiceTunnelIPv4));
     } else {
         red_printf("unexpected ip type=%d", redc_service->ip.type);
         tunnel_worker_free_print_service(worker, service);
@@ -1162,14 +1162,14 @@ static TunnelPrintService *tunnel_worker_add_print_service(TunnelWorker *worker,
 }
 
 static int tunnel_channel_handle_service_add(TunnelChannel *channel,
-                                             RedcTunnelAddGenericService *service_msg)
+                                             SpiceMsgcTunnelAddGenericService *service_msg)
 {
     TunnelService *out_service = NULL;
-    if (service_msg->type == RED_TUNNEL_SERVICE_TYPE_IPP) {
+    if (service_msg->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
         out_service = &tunnel_worker_add_print_service(channel->worker,
-                                                       (RedcTunnelAddPrintService *)
+                                                       (SpiceMsgcTunnelAddPrintService *)
                                                        service_msg)->base;
-    } else if (service_msg->type == RED_TUNNEL_SERVICE_TYPE_GENERIC) {
+    } else if (service_msg->type == SPICE_TUNNEL_SERVICE_TYPE_GENERIC) {
         out_service = tunnel_worker_add_service(channel->worker, sizeof(TunnelService),
                                                 service_msg);
     } else {
@@ -1214,9 +1214,9 @@ static inline void tunnel_worker_clear_routed_network(TunnelWorker *worker)
 {
     while (!ring_is_empty(&worker->services)) {
         TunnelService *service = (TunnelService *)ring_get_head(&worker->services);
-        if (service->type == RED_TUNNEL_SERVICE_TYPE_GENERIC) {
+        if (service->type == SPICE_TUNNEL_SERVICE_TYPE_GENERIC) {
             tunnel_worker_free_service(worker, service);
-        } else if (service->type == RED_TUNNEL_SERVICE_TYPE_IPP) {
+        } else if (service->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
             tunnel_worker_free_print_service(worker, (TunnelPrintService *)service);
         } else {
             red_error("unexpected service type");
@@ -1429,13 +1429,13 @@ static int tunnel_channel_handle_socket_connect_ack(TunnelChannel *channel, RedS
     red_printf("TUNNEL_DBG");
 #endif
     if (channel->mig_inprogress || channel->base.migrate) {
-        sckt->mig_client_status_msg = REDC_TUNNEL_SOCKET_OPEN_ACK;
+        sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK;
         sckt->mig_open_ack_tokens = tokens;
         return TRUE;
     }
 
     if (sckt->client_status != CLIENT_SCKT_STATUS_WAIT_OPEN) {
-        red_printf("unexpected REDC_TUNNEL_SOCKET_OPEN_ACK status=%d", sckt->client_status);
+        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK status=%d", sckt->client_status);
         return FALSE;
     }
     sckt->client_status = CLIENT_SCKT_STATUS_OPEN;
@@ -1462,12 +1462,12 @@ static int tunnel_channel_handle_socket_connect_nack(TunnelChannel *channel, Red
     PRINT_SCKT(sckt);
 #endif
     if (channel->mig_inprogress || channel->base.migrate) {
-        sckt->mig_client_status_msg = REDC_TUNNEL_SOCKET_OPEN_NACK;
+        sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK;
         return TRUE;
     }
 
     if (sckt->client_status != CLIENT_SCKT_STATUS_WAIT_OPEN) {
-        red_printf("unexpected REDC_TUNNEL_SOCKET_OPEN_NACK status=%d", sckt->client_status);
+        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK status=%d", sckt->client_status);
         return FALSE;
     }
     sckt->client_status = CLIENT_SCKT_STATUS_CLOSED;
@@ -1487,12 +1487,12 @@ static int tunnel_channel_handle_socket_fin(TunnelChannel *channel, RedSocket *s
     PRINT_SCKT(sckt);
 #endif
     if (channel->mig_inprogress || channel->base.migrate) {
-        sckt->mig_client_status_msg = REDC_TUNNEL_SOCKET_FIN;
+        sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_FIN;
         return TRUE;
     }
 
     if (sckt->client_status != CLIENT_SCKT_STATUS_OPEN) {
-        red_printf("unexpected REDC_TUNNEL_SOCKET_FIN status=%d", sckt->client_status);
+        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_FIN status=%d", sckt->client_status);
         return FALSE;
     }
     sckt->client_status = CLIENT_SCKT_STATUS_SHUTDOWN_SEND;
@@ -1525,7 +1525,7 @@ static int tunnel_channel_handle_socket_closed(TunnelChannel *channel, RedSocket
 #endif
 
     if (channel->mig_inprogress || channel->base.migrate) {
-        sckt->mig_client_status_msg = REDC_TUNNEL_SOCKET_CLOSED;
+        sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_CLOSED;
         return TRUE;
     }
 
@@ -1571,7 +1571,7 @@ static int tunnel_channel_handle_socket_closed_ack(TunnelChannel *channel, RedSo
     PRINT_SCKT(sckt);
 #endif
     if (channel->mig_inprogress || channel->base.migrate) {
-        sckt->mig_client_status_msg = REDC_TUNNEL_SOCKET_CLOSED_ACK;
+        sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK;
         return TRUE;
     }
 
@@ -1583,7 +1583,7 @@ static int tunnel_channel_handle_socket_closed_ack(TunnelChannel *channel, RedSo
     }
 
     if (sckt->slirp_status != SLIRP_SCKT_STATUS_CLOSED) {
-        red_printf("unexcpected REDC_TUNNEL_SOCKET_CLOSED_ACK slirp_status=%d",
+        red_printf("unexcpected SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK slirp_status=%d",
                    sckt->slirp_status);
         return FALSE;
     }
@@ -1597,7 +1597,7 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannel *channel, Red
 {
     if ((sckt->client_status == CLIENT_SCKT_STATUS_SHUTDOWN_SEND) ||
         (sckt->client_status == CLIENT_SCKT_STATUS_CLOSED)) {
-        red_printf("unexcpected REDC_TUNNEL_SOCKET_DATA clinet_status=%d",
+        red_printf("unexcpected SPICE_MSGC_TUNNEL_SOCKET_DATA clinet_status=%d",
                    sckt->client_status);
         return FALSE;
     }
@@ -1641,7 +1641,7 @@ static inline int __client_socket_can_receive(RedSocket *sckt)
 }
 
 static int tunnel_channel_handle_socket_token(TunnelChannel *channel, RedSocket *sckt,
-                                              RedcTunnelSocketTokens *message)
+                                              SpiceMsgcTunnelSocketTokens *message)
 {
     sckt->out_data.num_tokens += message->num_tokens;
 
@@ -1655,13 +1655,13 @@ static int tunnel_channel_handle_socket_token(TunnelChannel *channel, RedSocket
     return TRUE;
 }
 
-static uint8_t *tunnel_channel_alloc_msg_rcv_buf(RedChannel *channel, RedDataHeader *msg_header)
+static uint8_t *tunnel_channel_alloc_msg_rcv_buf(RedChannel *channel, SpiceDataHeader *msg_header)
 {
     TunnelChannel *tunnel_channel = (TunnelChannel *)channel;
-    if (msg_header->type == REDC_TUNNEL_SOCKET_DATA) {
+    if (msg_header->type == SPICE_MSGC_TUNNEL_SOCKET_DATA) {
         return (__tunnel_worker_alloc_socket_rcv_buf(tunnel_channel->worker)->buf);
-    } else if ((msg_header->type == REDC_MIGRATE_DATA) ||
-               (msg_header->type == REDC_TUNNEL_SERVICE_ADD)) {
+    } else if ((msg_header->type == SPICE_MSGC_MIGRATE_DATA) ||
+               (msg_header->type == SPICE_MSGC_TUNNEL_SERVICE_ADD)) {
         uint8_t *ret = malloc(msg_header->size);
         if (!ret) {
             red_error("failed allocating");
@@ -1673,11 +1673,11 @@ static uint8_t *tunnel_channel_alloc_msg_rcv_buf(RedChannel *channel, RedDataHea
 }
 
 // called by the receive routine of the channel, before the buffer was assigned to a socket
-static void tunnel_channel_release_msg_rcv_buf(RedChannel *channel, RedDataHeader *msg_header,
+static void tunnel_channel_release_msg_rcv_buf(RedChannel *channel, SpiceDataHeader *msg_header,
                                                uint8_t *msg)
 {
     TunnelChannel *tunnel_channel = (TunnelChannel *)channel;
-    if (msg_header->type == REDC_TUNNEL_SOCKET_DATA) {
+    if (msg_header->type == SPICE_MSGC_TUNNEL_SOCKET_DATA) {
         ASSERT(!(CONTAINEROF(msg, RedSocketRawRcvBuf, buf)->base.usr_opaque));
         __tunnel_worker_free_socket_rcv_buf(tunnel_channel->worker,
                                             CONTAINEROF(msg, RedSocketRawRcvBuf, buf));
@@ -1690,9 +1690,9 @@ static void __tunnel_channel_fill_service_migrate_item(TunnelChannel *channel,
 {
     migrate_item->service = service;
     TunnelMigrateService *general_data;
-    if (service->type == RED_TUNNEL_SERVICE_TYPE_GENERIC) {
+    if (service->type == SPICE_TUNNEL_SERVICE_TYPE_GENERIC) {
         general_data = &migrate_item->u.generic_service;
-    } else if (service->type == RED_TUNNEL_SERVICE_TYPE_IPP) {
+    } else if (service->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
         general_data = &migrate_item->u.print_service.base;
         memcpy(migrate_item->u.print_service.ip, ((TunnelPrintService *)service)->ip, 4);
     } else {
@@ -1728,8 +1728,8 @@ static void __tunnel_channel_fill_socket_migrate_item(TunnelChannel *channel, Re
 
     // checking if there is a need to save the queues
     if ((sckt->client_status != CLIENT_SCKT_STATUS_CLOSED) &&
-        (sckt->mig_client_status_msg != REDC_TUNNEL_SOCKET_CLOSED) &&
-        (sckt->mig_client_status_msg != REDC_TUNNEL_SOCKET_CLOSED_ACK)) {
+        (sckt->mig_client_status_msg != SPICE_MSGC_TUNNEL_SOCKET_CLOSED) &&
+        (sckt->mig_client_status_msg != SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK)) {
         mig_sckt->out_data.process_queue_size =
             sckt->out_data.process_queue->get_migrate_data_proc(sckt->out_data.process_queue,
                                                                 &migrate_item->out_process_queue);
@@ -1976,9 +1976,9 @@ static void tunnel_channel_restore_migrated_service(TunnelChannel *channel,
     int service_size;
     TunnelService *service;
     struct in_addr virt_ip;
-    if (mig_service->type == RED_TUNNEL_SERVICE_TYPE_GENERIC) {
+    if (mig_service->type == SPICE_TUNNEL_SERVICE_TYPE_GENERIC) {
         service_size = sizeof(TunnelService);
-    } else if (mig_service->type == RED_TUNNEL_SERVICE_TYPE_IPP) {
+    } else if (mig_service->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
         service_size = sizeof(TunnelPrintService);
     } else {
         SET_TUNNEL_ERROR(channel, "unexpected service type");
@@ -1996,7 +1996,7 @@ static void tunnel_channel_restore_migrated_service(TunnelChannel *channel,
         return;
     }
 
-    if (service->type == RED_TUNNEL_SERVICE_TYPE_IPP) {
+    if (service->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
         TunnelMigratePrintService *mig_print_service = (TunnelMigratePrintService *)mig_service;
         TunnelPrintService *print_service = (TunnelPrintService *)service;
 
@@ -2098,14 +2098,14 @@ static void tunnel_channel_restore_socket_state(TunnelChannel *channel, RedSocke
     switch (sckt->mig_client_status_msg) {
     case 0:
         break;
-    case REDC_TUNNEL_SOCKET_OPEN_ACK:
+    case SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK:
         ret = tunnel_channel_handle_socket_connect_ack(channel, sckt,
                                                        sckt->mig_open_ack_tokens);
         break;
-    case REDC_TUNNEL_SOCKET_OPEN_NACK:
+    case SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK:
         ret = tunnel_channel_handle_socket_connect_nack(channel, sckt);
         break;
-    case REDC_TUNNEL_SOCKET_FIN:
+    case SPICE_MSGC_TUNNEL_SOCKET_FIN:
         if (sckt->client_status == CLIENT_SCKT_STATUS_WAIT_OPEN) {
             ret = tunnel_channel_handle_socket_connect_ack(channel, sckt,
                                                            sckt->mig_open_ack_tokens);
@@ -2114,7 +2114,7 @@ static void tunnel_channel_restore_socket_state(TunnelChannel *channel, RedSocke
             ret = tunnel_channel_handle_socket_fin(channel, sckt);
         }
         break;
-    case REDC_TUNNEL_SOCKET_CLOSED:
+    case SPICE_MSGC_TUNNEL_SOCKET_CLOSED:
         // can't just send nack since we need to send close ack to client
         if (sckt->client_status == CLIENT_SCKT_STATUS_WAIT_OPEN) {
             ret = tunnel_channel_handle_socket_connect_ack(channel, sckt,
@@ -2123,7 +2123,7 @@ static void tunnel_channel_restore_socket_state(TunnelChannel *channel, RedSocke
         ret = ret & tunnel_channel_handle_socket_closed(channel, sckt);
 
         break;
-    case REDC_TUNNEL_SOCKET_CLOSED_ACK:
+    case SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK:
         ret = tunnel_channel_handle_socket_closed_ack(channel, sckt);
         break;
     default:
@@ -2259,24 +2259,24 @@ error:
 }
 
 //  msg was allocated by tunnel_channel_alloc_msg_rcv_buf
-static int tunnel_channel_handle_message(RedChannel *channel, RedDataHeader *header, uint8_t *msg)
+static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *header, uint8_t *msg)
 {
     TunnelChannel *tunnel_channel = (TunnelChannel *)channel;
     RedSocket *sckt = NULL;
     // retrieve the sckt
     switch (header->type) {
-    case REDC_MIGRATE_FLUSH_MARK:
-    case REDC_MIGRATE_DATA:
-    case REDC_TUNNEL_SERVICE_ADD:
-    case REDC_TUNNEL_SERVICE_REMOVE:
+    case SPICE_MSGC_MIGRATE_FLUSH_MARK:
+    case SPICE_MSGC_MIGRATE_DATA:
+    case SPICE_MSGC_TUNNEL_SERVICE_ADD:
+    case SPICE_MSGC_TUNNEL_SERVICE_REMOVE:
         break;
-    case REDC_TUNNEL_SOCKET_OPEN_ACK:
-    case REDC_TUNNEL_SOCKET_OPEN_NACK:
-    case REDC_TUNNEL_SOCKET_DATA:
-    case REDC_TUNNEL_SOCKET_FIN:
-    case REDC_TUNNEL_SOCKET_CLOSED:
-    case REDC_TUNNEL_SOCKET_CLOSED_ACK:
-    case REDC_TUNNEL_SOCKET_TOKEN:
+    case SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK:
+    case SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK:
+    case SPICE_MSGC_TUNNEL_SOCKET_DATA:
+    case SPICE_MSGC_TUNNEL_SOCKET_FIN:
+    case SPICE_MSGC_TUNNEL_SOCKET_CLOSED:
+    case SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK:
+    case SPICE_MSGC_TUNNEL_SOCKET_TOKEN:
         // the first field in these messages is connection id
         sckt = tunnel_channel->worker->sockets + (*((uint16_t *)msg));
         if (!sckt->allocated) {
@@ -2289,73 +2289,73 @@ static int tunnel_channel_handle_message(RedChannel *channel, RedDataHeader *hea
     }
 
     switch (header->type) {
-    case REDC_TUNNEL_SERVICE_ADD:
-        if (header->size < sizeof(RedcTunnelAddGenericService)) {
+    case SPICE_MSGC_TUNNEL_SERVICE_ADD:
+        if (header->size < sizeof(SpiceMsgcTunnelAddGenericService)) {
             red_printf("bad message size");
             free(msg);
             return FALSE;
         }
         return tunnel_channel_handle_service_add(tunnel_channel,
-                                                 (RedcTunnelAddGenericService *)msg);
-    case REDC_TUNNEL_SERVICE_REMOVE:
+                                                 (SpiceMsgcTunnelAddGenericService *)msg);
+    case SPICE_MSGC_TUNNEL_SERVICE_REMOVE:
         red_printf("REDC_TUNNEL_REMOVE_SERVICE not supported yet");
         return FALSE;
-    case REDC_TUNNEL_SOCKET_OPEN_ACK:
-        if (header->size != sizeof(RedcTunnelSocketOpenAck)) {
+    case SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK:
+        if (header->size != sizeof(SpiceMsgcTunnelSocketOpenAck)) {
             red_printf("bad message size");
             return FALSE;
         }
 
         return tunnel_channel_handle_socket_connect_ack(tunnel_channel, sckt,
-                                                        ((RedcTunnelSocketOpenAck *)msg)->tokens);
+                                                        ((SpiceMsgcTunnelSocketOpenAck *)msg)->tokens);
 
-    case REDC_TUNNEL_SOCKET_OPEN_NACK:
-        if (header->size != sizeof(RedcTunnelSocketOpenNack)) {
+    case SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK:
+        if (header->size != sizeof(SpiceMsgcTunnelSocketOpenNack)) {
             red_printf("bad message size");
             return FALSE;
         }
 
         return tunnel_channel_handle_socket_connect_nack(tunnel_channel, sckt);
-    case REDC_TUNNEL_SOCKET_DATA:
+    case SPICE_MSGC_TUNNEL_SOCKET_DATA:
     {
-        if (header->size < sizeof(RedcTunnelSocketData)) {
+        if (header->size < sizeof(SpiceMsgcTunnelSocketData)) {
             red_printf("bad message size");
             return FALSE;
         }
 
         return tunnel_channel_handle_socket_receive_data(tunnel_channel, sckt,
                                                     CONTAINEROF(msg, RedSocketRawRcvBuf, buf),
-                                                    header->size - sizeof(RedcTunnelSocketData));
+                                                    header->size - sizeof(SpiceMsgcTunnelSocketData));
     }
-    case REDC_TUNNEL_SOCKET_FIN:
-        if (header->size != sizeof(RedcTunnelSocketFin)) {
+    case SPICE_MSGC_TUNNEL_SOCKET_FIN:
+        if (header->size != sizeof(SpiceMsgcTunnelSocketFin)) {
             red_printf("bad message size");
             return FALSE;
         }
         return tunnel_channel_handle_socket_fin(tunnel_channel, sckt);
-    case REDC_TUNNEL_SOCKET_CLOSED:
-        if (header->size != sizeof(RedcTunnelSocketClosed)) {
+    case SPICE_MSGC_TUNNEL_SOCKET_CLOSED:
+        if (header->size != sizeof(SpiceMsgcTunnelSocketClosed)) {
             red_printf("bad message size");
             return FALSE;
         }
         return tunnel_channel_handle_socket_closed(tunnel_channel, sckt);
-    case REDC_TUNNEL_SOCKET_CLOSED_ACK:
-        if (header->size != sizeof(RedcTunnelSocketClosedAck)) {
+    case SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK:
+        if (header->size != sizeof(SpiceMsgcTunnelSocketClosedAck)) {
             red_printf("bad message size");
             return FALSE;
         }
         return tunnel_channel_handle_socket_closed_ack(tunnel_channel, sckt);
-    case REDC_TUNNEL_SOCKET_TOKEN:
-        if (header->size != sizeof(RedcTunnelSocketTokens)) {
+    case SPICE_MSGC_TUNNEL_SOCKET_TOKEN:
+        if (header->size != sizeof(SpiceMsgcTunnelSocketTokens)) {
             red_printf("bad message size");
             return FALSE;
         }
 
         return tunnel_channel_handle_socket_token(tunnel_channel, sckt,
-                                                  (RedcTunnelSocketTokens *)msg);
-    case REDC_MIGRATE_FLUSH_MARK:
+                                                  (SpiceMsgcTunnelSocketTokens *)msg);
+    case SPICE_MSGC_MIGRATE_FLUSH_MARK:
         return tunnel_channel_handle_migrate_mark(tunnel_channel);
-    case REDC_MIGRATE_DATA:
+    case SPICE_MSGC_MIGRATE_DATA:
         if (header->size < sizeof(TunnelMigrateData)) {
             red_printf("bad message size");
             free(msg);
@@ -2379,8 +2379,8 @@ static void tunnel_channel_send_set_ack(TunnelChannel *channel, PipeItem *item)
     channel->base.send_data.u.ack.generation = ++channel->base.ack_data.generation;
     channel->base.send_data.u.ack.window = CLIENT_ACK_WINDOW;
 
-    red_channel_init_send_data(&channel->base, RED_SET_ACK, item);
-    red_channel_add_buf(&channel->base, &channel->base.send_data.u.ack, sizeof(RedSetAck));
+    red_channel_init_send_data(&channel->base, SPICE_MSG_SET_ACK, item);
+    red_channel_add_buf(&channel->base, &channel->base.send_data.u.ack, sizeof(SpiceMsgSetAck));
 
     red_channel_begin_send_massage(&channel->base);
 }
@@ -2388,11 +2388,11 @@ static void tunnel_channel_send_set_ack(TunnelChannel *channel, PipeItem *item)
 static void tunnel_channel_send_migrate(TunnelChannel *channel, PipeItem *item)
 {
     ASSERT(channel);
-    channel->base.send_data.u.migrate.flags = RED_MIGRATE_NEED_FLUSH |
-        RED_MIGRATE_NEED_DATA_TRANSFER;
+    channel->base.send_data.u.migrate.flags = SPICE_MIGRATE_NEED_FLUSH |
+        SPICE_MIGRATE_NEED_DATA_TRANSFER;
     channel->expect_migrate_mark = TRUE;
-    red_channel_init_send_data(&channel->base, RED_MIGRATE, item);
-    red_channel_add_buf(&channel->base, &channel->base.send_data.u.migrate, sizeof(RedMigrate));
+    red_channel_init_send_data(&channel->base, SPICE_MSG_MIGRATE, item);
+    red_channel_add_buf(&channel->base, &channel->base.send_data.u.migrate, sizeof(SpiceMsgMigrate));
     red_channel_begin_send_massage(&channel->base);
 }
 
@@ -2438,12 +2438,12 @@ static int __tunnel_channel_send_service_migrate_data(TunnelChannel *channel,
     int cur_offset = offset;
     TunnelMigrateService *generic_data;
 
-    if (service->type == RED_TUNNEL_SERVICE_TYPE_GENERIC) {
+    if (service->type == SPICE_TUNNEL_SERVICE_TYPE_GENERIC) {
         generic_data = &item->u.generic_service;
         red_channel_add_buf(&channel->base, &item->u.generic_service,
                             sizeof(item->u.generic_service));
         cur_offset += sizeof(item->u.generic_service);
-    } else if (service->type == RED_TUNNEL_SERVICE_TYPE_IPP) {
+    } else if (service->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
         generic_data = &item->u.print_service.base;
         red_channel_add_buf(&channel->base, &item->u.print_service,
                             sizeof(item->u.print_service));
@@ -2474,8 +2474,8 @@ static int __tunnel_channel_send_socket_migrate_data(TunnelChannel *channel,
     cur_offset += sizeof(*mig_sckt);
 
     if ((sckt->client_status != CLIENT_SCKT_STATUS_CLOSED) &&
-        (sckt->mig_client_status_msg != REDC_TUNNEL_SOCKET_CLOSED) &&
-        (sckt->mig_client_status_msg != REDC_TUNNEL_SOCKET_CLOSED_ACK)) {
+        (sckt->mig_client_status_msg != SPICE_MSGC_TUNNEL_SOCKET_CLOSED) &&
+        (sckt->mig_client_status_msg != SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK)) {
         mig_sckt->out_data.process_buf = cur_offset;
         mig_sckt->out_data.process_buf_size =
             __tunnel_channel_send_process_bufs_migrate_data(channel,
@@ -2541,7 +2541,7 @@ static void tunnel_channel_send_migrate_data(TunnelChannel *channel, PipeItem *i
     migrate_data->magic = TUNNEL_MIGRATE_DATA_MAGIC;
     migrate_data->version = TUNNEL_MIGRATE_DATA_VERSION;
     migrate_data->message_serial = red_channel_get_message_serial(&channel->base);
-    red_channel_init_send_data(&channel->base, RED_MIGRATE_DATA, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_MIGRATE_DATA, item);
     red_channel_add_buf(&channel->base, migrate_data, sizeof(*migrate_data));
 
     migrate_data->slirp_state = data_buf_offset;
@@ -2583,8 +2583,8 @@ static void tunnel_channel_send_init(TunnelChannel *channel, PipeItem *item)
     channel->send_data.u.init.max_socket_data_size = MAX_SOCKET_DATA_SIZE;
     channel->send_data.u.init.max_num_of_sockets = MAX_SOCKETS_NUM;
 
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_INIT, item);
-    red_channel_add_buf(&channel->base, &channel->send_data.u.init, sizeof(RedTunnelInit));
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_INIT, item);
+    red_channel_add_buf(&channel->base, &channel->send_data.u.init, sizeof(SpiceMsgTunnelInit));
 
     red_channel_begin_send_massage(&channel->base);
 }
@@ -2594,12 +2594,12 @@ static void tunnel_channel_send_service_ip_map(TunnelChannel *channel, PipeItem
     TunnelService *service = CONTAINEROF(item, TunnelService, pipe_item);
 
     channel->send_data.u.service_ip.service_id = service->id;
-    channel->send_data.u.service_ip.virtual_ip.type = RED_TUNNEL_IP_TYPE_IPv4;
+    channel->send_data.u.service_ip.virtual_ip.type = SPICE_TUNNEL_IP_TYPE_IPv4;
 
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SERVICE_IP_MAP, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SERVICE_IP_MAP, item);
     red_channel_add_buf(&channel->base, &channel->send_data.u.service_ip,
-                        sizeof(RedTunnelServiceIpMap));
-    red_channel_add_buf(&channel->base, &service->virt_ip.s_addr, sizeof(RedTunnelIPv4));
+                        sizeof(SpiceMsgTunnelServiceIpMap));
+    red_channel_add_buf(&channel->base, &service->virt_ip.s_addr, sizeof(SpiceTunnelIPv4));
     red_channel_begin_send_massage(&channel->base);
 }
 
@@ -2614,7 +2614,7 @@ static void tunnel_channel_send_socket_open(TunnelChannel *channel, PipeItem *it
 
     sckt->in_data.client_total_num_tokens = SOCKET_WINDOW_SIZE;
     sckt->in_data.num_tokens = 0;
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SOCKET_OPEN, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SOCKET_OPEN, item);
     red_channel_add_buf(&channel->base, &channel->send_data.u.socket_open,
                         sizeof(channel->send_data.u.socket_open));
 
@@ -2639,7 +2639,7 @@ static void tunnel_channel_send_socket_fin(TunnelChannel *channel, PipeItem *ite
 
     channel->send_data.u.socket_fin.connection_id = sckt->connection_id;
 
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SOCKET_FIN, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SOCKET_FIN, item);
     red_channel_add_buf(&channel->base, &channel->send_data.u.socket_fin,
                         sizeof(channel->send_data.u.socket_fin));
 
@@ -2671,7 +2671,7 @@ static void tunnel_channel_send_socket_close(TunnelChannel *channel, PipeItem *i
 
     channel->send_data.u.socket_close.connection_id = sckt->connection_id;
 
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SOCKET_CLOSE, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SOCKET_CLOSE, item);
     red_channel_add_buf(&channel->base, &channel->send_data.u.socket_close,
                         sizeof(channel->send_data.u.socket_close));
 
@@ -2690,7 +2690,7 @@ static void tunnel_channel_send_socket_closed_ack(TunnelChannel *channel, PipeIt
     channel->send_data.u.socket_close_ack.connection_id = sckt->connection_id;
 
     // pipe item is null because we free the sckt.
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SOCKET_CLOSED_ACK, NULL);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SOCKET_CLOSED_ACK, NULL);
     red_channel_add_buf(&channel->base, &channel->send_data.u.socket_close_ack,
                         sizeof(channel->send_data.u.socket_close_ack));
 
@@ -2727,7 +2727,7 @@ static void tunnel_channel_send_socket_token(TunnelChannel *channel, PipeItem *i
     sckt->in_data.client_total_num_tokens += channel->send_data.u.socket_token.num_tokens;
     ASSERT(sckt->in_data.client_total_num_tokens <= SOCKET_WINDOW_SIZE);
 
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SOCKET_TOKEN, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SOCKET_TOKEN, item);
     red_channel_add_buf(&channel->base, &channel->send_data.u.socket_token,
                         sizeof(channel->send_data.u.socket_token));
 
@@ -2757,7 +2757,7 @@ static void tunnel_channel_send_socket_out_data(TunnelChannel *channel, PipeItem
 
     channel->send_data.u.socket_data.connection_id = sckt->connection_id;
 
-    red_channel_init_send_data(&channel->base, RED_TUNNEL_SOCKET_DATA, item);
+    red_channel_init_send_data(&channel->base, SPICE_MSG_TUNNEL_SOCKET_DATA, item);
     red_channel_add_buf(&channel->base, &channel->send_data.u.socket_data,
                         sizeof(channel->send_data.u.socket_data));
     pushed_bufs_num++;
diff --git a/server/red_worker.c b/server/red_worker.c
index 572b3224..9d6c08e5 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -295,9 +295,9 @@ typedef struct CursorItem {
 
 typedef struct LocalCursor {
     CursorItem base;
-    Point16 position;
+    SpicePoint16 position;
     uint32_t data_size;
-    RedCursor red_cursor;
+    SpiceCursor red_cursor;
 } LocalCursor;
 
 #define MAX_SEND_BUFS 20
@@ -331,7 +331,7 @@ typedef struct RedChannel RedChannel;
 typedef void (*disconnect_channel_proc)(RedChannel *channel);
 typedef void (*hold_item_proc)(void *item);
 typedef void (*release_item_proc)(RedChannel *channel, void *item);
-typedef int (*handle_message_proc)(RedChannel *channel, RedDataHeader *message);
+typedef int (*handle_message_proc)(RedChannel *channel, SpiceDataHeader *message);
 
 struct RedChannel {
     EventListener listener;
@@ -350,9 +350,9 @@ struct RedChannel {
 
     struct {
         int blocked;
-        RedDataHeader header;
+        SpiceDataHeader header;
         union {
-            RedSetAck ack;
+            SpiceMsgSetAck ack;
         } u;
         uint32_t n_bufs;
         BufDescriptor bufs[MAX_SEND_BUFS];
@@ -363,7 +363,7 @@ struct RedChannel {
 
     struct {
         uint8_t buf[RECIVE_BUF_SIZE];
-        RedDataHeader *message;
+        SpiceDataHeader *message;
         uint8_t *now;
         uint8_t *end;
     } recive_data;
@@ -380,7 +380,7 @@ struct RedChannel {
 typedef struct ImageItem {
     PipeItem link;
     int refs;
-    Point pos;
+    SpicePoint pos;
     int width;
     int height;
     int stride;
@@ -398,7 +398,7 @@ struct Stream {
     red_time_t last_time;
     int width;
     int height;
-    Rect dest_area;
+    SpiceRect dest_area;
 #endif
     int top_down;
     Stream *next;
@@ -442,12 +442,12 @@ static const int BITMAP_FMT_IS_RGB[] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
 static const int BITMAP_FMP_BYTES_PER_PIXEL[] = {0, 0, 0, 0, 0, 1, 2, 3, 4, 4};
 
 typedef struct  __attribute__ ((__packed__)) RedImage {
-    ImageDescriptor descriptor;
+    SpiceImageDescriptor descriptor;
     union { // variable length
-        Bitmap bitmap;
-        QUICData quic;
-        LZ_RGBData lz_rgb;
-        LZ_PLTData lz_plt;
+        SpiceBitmap bitmap;
+        SpiceQUICData quic;
+        SpiceLZRGBData lz_rgb;
+        SpiceLZPLTData lz_plt;
     };
 } RedImage;
 
@@ -499,13 +499,13 @@ typedef struct __attribute__ ((__packed__)) DisplayChannelMigrateData {
 } DisplayChannelMigrateData;
 
 typedef struct WaitForChannels {
-    RedWaitForChannels header;
-    RedWaitForChannel buf[MAX_CACHE_CLIENTS];
+    SpiceMsgWaitForChannels header;
+    SpiceWaitForChannel buf[MAX_CACHE_CLIENTS];
 } WaitForChannels;
 
 typedef struct FreeList {
     int res_size;
-    RedResorceList *res;
+    SpiceResorceList *res;
     uint64_t sync[MAX_CACHE_CLIENTS];
     WaitForChannels wait;
 } FreeList;
@@ -524,7 +524,7 @@ typedef struct  {
     jmp_buf jmp_env;
     union {
         struct {
-            ADDRESS next;
+            SPICE_ADDRESS next;
             uint32_t stride;
             uint32_t group_id;
 
@@ -629,30 +629,30 @@ struct DisplayChannel {
 
     struct {
         union {
-            RedFill fill;
-            RedOpaque opaque;
-            RedCopy copy;
-            RedTransparent transparent;
-            RedAlphaBlend alpha_blend;
-            RedCopyBits copy_bits;
-            RedBlend blend;
-            RedRop3 rop3;
-            RedBlackness blackness;
-            RedWhiteness whiteness;
-            RedInvers invers;
-            RedStroke stroke;
-            RedText text;
-            RedMode mode;
-            RedInvalOne inval_one;
+            SpiceMsgDisplayDrawFill fill;
+            SpiceMsgDisplayDrawOpaque opaque;
+            SpiceMsgDisplayDrawCopy copy;
+            SpiceMsgDisplayDrawTransparent transparent;
+            SpiceMsgDisplayDrawAlphaBlend alpha_blend;
+            SpiceMsgDisplayCopyBits copy_bits;
+            SpiceMsgDisplayDrawBlend blend;
+            SpiceMsgDisplayDrawRop3 rop3;
+            SpiceMsgDisplayDrawBlackness blackness;
+            SpiceMsgDisplayDrawWhiteness whiteness;
+            SpiceMsgDisplayDrawInvers invers;
+            SpiceMsgDisplayDrawStroke stroke;
+            SpiceMsgDisplayDrawText text;
+            SpiceMsgDisplayMode mode;
+            SpiceMsgDisplayInvalOne inval_one;
             WaitForChannels wait;
             struct {
-                RedStreamCreate message;
+                SpiceMsgDisplayStreamCreate message;
                 uint32_t num_rects;
             } stream_create;
-            RedStreamClip stream_clip;
-            RedStreamData stream_data;
-            RedStreamDestroy stream_destroy;
-            RedMigrate migrate;
+            SpiceMsgDisplayStreamClip stream_clip;
+            SpiceMsgDisplayStreamData stream_data;
+            SpiceMsgDisplayStreamDestroy stream_destroy;
+            SpiceMsgMigrate migrate;
             DisplayChannelMigrateData migrate_data;
         } u;
 
@@ -666,10 +666,10 @@ struct DisplayChannel {
         RedCompressBuf *used_compress_bufs;
 
         struct {
-            RedSubMessageList sub_list;
+            SpiceSubMessageList sub_list;
             uint32_t sub_messages[DISPLAY_MAX_SUB_MESSAGES];
         } sub_list;
-        RedSubMessage sub_header[DISPLAY_MAX_SUB_MESSAGES];
+        SpicedSubMessage sub_header[DISPLAY_MAX_SUB_MESSAGES];
 
         FreeList free_list;
     } send_data;
@@ -697,12 +697,12 @@ typedef struct CursorChannel {
 
     struct {
         union {
-            RedCursorInit cursor_init;
-            RedCursorSet cursor_set;
-            RedCursorMove cursor_move;
-            RedCursorTrail cursor_trail;
-            RedInvalOne inval_one;
-            RedMigrate migrate;
+            SpiceMsgCursorInit cursor_init;
+            SpiceMsgCursorSet cursor_set;
+            SpiceMsgCursorMove cursor_move;
+            SpiceMsgCursorTrail cursor_trail;
+            SpiceMsgDisplayInvalOne inval_one;
+            SpiceMsgMigrate migrate;
         } u;
     } send_data;
 #ifdef RED_STATISTICS
@@ -828,23 +828,23 @@ typedef struct UpgradeItem {
     QRegion region;
 } UpgradeItem;
 
-typedef void (*draw_fill_t)(void *canvas, Rect *bbox, Clip *clip, Fill *fill);
-typedef void (*draw_copy_t)(void *canvas, Rect *bbox, Clip *clip, Copy *copy);
-typedef void (*draw_opaque_t)(void *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
-typedef void (*copy_bits_t)(void *canvas, Rect *bbox, Clip *clip, Point *src_pos);
-typedef void (*draw_text_t)(void *canvas, Rect *bbox, Clip *clip, Text *text);
-typedef void (*draw_stroke_t)(void *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
-typedef void (*draw_rop3_t)(void *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
-typedef void (*draw_blend_t)(void *canvas, Rect *bbox, Clip *clip, Blend *blend);
-typedef void (*draw_blackness_t)(void *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
-typedef void (*draw_whiteness_t)(void *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
-typedef void (*draw_invers_t)(void *canvas, Rect *bbox, Clip *clip, Invers *invers);
-typedef void (*draw_transparent_t)(void *canvas, Rect *bbox, Clip *clip, Transparent* transparent);
-typedef void (*draw_alpha_blend_t)(void *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
-typedef void (*read_pixels_t)(void *canvas, uint8_t *dest, int dest_stride, const Rect *area);
-typedef void (*set_top_mask_t)(void *canvas, int num_rect, const Rect *rects);
+typedef void (*draw_fill_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceFill *fill);
+typedef void (*draw_copy_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceCopy *copy);
+typedef void (*draw_opaque_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceOpaque *opaque);
+typedef void (*copy_bits_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpicePoint *src_pos);
+typedef void (*draw_text_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceText *text);
+typedef void (*draw_stroke_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceStroke *stroke);
+typedef void (*draw_rop3_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceRop3 *rop3);
+typedef void (*draw_blend_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlend *blend);
+typedef void (*draw_blackness_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceBlackness *blackness);
+typedef void (*draw_whiteness_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceWhiteness *whiteness);
+typedef void (*draw_invers_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceInvers *invers);
+typedef void (*draw_transparent_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceTransparent* transparent);
+typedef void (*draw_alpha_blend_t)(void *canvas, SpiceRect *bbox, SpiceClip *clip, SpiceAlphaBlnd* alpha_blend);
+typedef void (*read_pixels_t)(void *canvas, uint8_t *dest, int dest_stride, const SpiceRect *area);
+typedef void (*set_top_mask_t)(void *canvas, int num_rect, const SpiceRect *rects);
 typedef void (*clear_top_mask_t)(void *canvas);
-typedef void (*validate_area_t)(void *canvas, int32_t stride, uint8_t *line_0, const Rect *area);
+typedef void (*validate_area_t)(void *canvas, int32_t stride, uint8_t *line_0, const SpiceRect *area);
 typedef void (*destroy_t)(void *canvas);
 
 typedef struct DrawFuncs {
@@ -891,7 +891,7 @@ typedef struct ItemTrace {
     int last_gradual_frame;
     int width;
     int height;
-    Rect dest_area;
+    SpiceRect dest_area;
 } ItemTrace;
 
 #define TRACE_ITEMS_SHIFT 3
@@ -943,7 +943,7 @@ typedef struct RedWorker {
 
     CursorItem *cursor;
     int cursor_visible;
-    Point16 cursor_position;
+    SpicePoint16 cursor_position;
     uint16_t cursor_trail_length;
     uint16_t cursor_trail_frequency;
 
@@ -1017,7 +1017,7 @@ static void display_channel_push(RedWorker *worker);
 #define red_draw_drawable(worker, item)
 #else
 static void red_draw_drawable(RedWorker *worker, Drawable *item);
-static void red_update_area(RedWorker *worker, const Rect *area);
+static void red_update_area(RedWorker *worker, const SpiceRect *area);
 #endif
 static void red_release_cursor(RedWorker *worker, CursorItem *cursor);
 static inline void release_drawable(RedWorker *worker, Drawable *item);
@@ -1039,11 +1039,11 @@ static void red_display_release_stream_clip(DisplayChannel* channel, StreamClipI
 static int red_display_free_some_independent_glz_drawables(DisplayChannel *channel);
 static void red_display_free_glz_drawable(DisplayChannel *channel, RedGlzDrawable *drawable);
 static void reset_rate(StreamAgent *stream_agent);
-static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap, uint32_t group_id);
-static inline int _stride_is_extra(Bitmap *bitmap);
+static int _bitmap_is_gradual(RedWorker *worker, SpiceBitmap *bitmap, uint32_t group_id);
+static inline int _stride_is_extra(SpiceBitmap *bitmap);
 
 #ifdef DUMP_BITMAP
-static void dump_bitmap(RedWorker *worker, Bitmap *bitmap, uint32_t group_id);
+static void dump_bitmap(RedWorker *worker, SpiceBitmap *bitmap, uint32_t group_id);
 #endif
 
 #ifdef COMPRESS_STAT
@@ -1644,7 +1644,7 @@ static inline void red_add_item_trace(RedWorker *worker, Drawable *item)
     trace->frames_count = item->frames_count;
     trace->gradual_frames_count = item->gradual_frames_count;
     trace->last_gradual_frame = item->last_gradual_frame;
-    Rect* src_area = &item->qxl_drawable->u.copy.src_area;
+    SpiceRect* src_area = &item->qxl_drawable->u.copy.src_area;
     trace->width = src_area->right - src_area->left;
     trace->height = src_area->bottom - src_area->top;
     trace->dest_area = item->qxl_drawable->bbox;
@@ -2118,7 +2118,7 @@ static inline void __current_add_drawable(RedWorker *worker, Drawable *drawable,
 
 #ifdef USE_EXCLUDE_RGN
 
-static int is_equal_path(RedWorker *worker, ADDRESS p1, ADDRESS p2, uint32_t group_id1,
+static int is_equal_path(RedWorker *worker, SPICE_ADDRESS p1, SPICE_ADDRESS p2, uint32_t group_id1,
                          uint32_t group_id2)
 {
     QXLPath *path1;
@@ -2181,13 +2181,13 @@ static int is_equal_path(RedWorker *worker, ADDRESS p1, ADDRESS p2, uint32_t gro
 }
 
 // partial imp
-static int is_equal_brush(Brush *b1, Brush *b2)
+static int is_equal_brush(SpiceBrush *b1, SpiceBrush *b2)
 {
-    return b1->type == b2->type && b1->type == BRUSH_TYPE_SOLID && b1->u.color == b1->u.color;
+    return b1->type == b2->type && b1->type == SPICE_BRUSH_TYPE_SOLID && b1->u.color == b1->u.color;
 }
 
 // partial imp
-static int is_equal_line_attr(LineAttr *a1, LineAttr *a2)
+static int is_equal_line_attr(SpiceLineAttr *a1, SpiceLineAttr *a2)
 {
     return a1->flags == a2->flags && a1->join_style == a2->join_style &&
            a1->end_style == a2->end_style && a1->style_nseg == a2->style_nseg &&
@@ -2195,7 +2195,7 @@ static int is_equal_line_attr(LineAttr *a1, LineAttr *a2)
            a1->style_nseg == 0;
 }
 
-static inline int rect_is_equal(const Rect *r1, const Rect *r2)
+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;
@@ -2293,11 +2293,11 @@ static void push_stream_clip_by_drawable(DisplayChannel* channel, StreamAgent *a
         PANIC("alloc failed");
     }
 
-    if (drawable->qxl_drawable->clip.type == CLIP_TYPE_NONE) {
+    if (drawable->qxl_drawable->clip.type == SPICE_CLIP_TYPE_NONE) {
         region_init(&item->region);
-        item->clip_type = CLIP_TYPE_NONE;
+        item->clip_type = SPICE_CLIP_TYPE_NONE;
     } else {
-        item->clip_type = CLIP_TYPE_RECTS;
+        item->clip_type = SPICE_CLIP_TYPE_RECTS;
         region_clone(&item->region, &drawable->tree_item.base.rgn);
     }
     red_pipe_add((RedChannel*)channel, (PipeItem *)item);
@@ -2309,7 +2309,7 @@ static void push_stream_clip(DisplayChannel* channel, StreamAgent *agent)
     if (!item) {
         PANIC("alloc failed");
     }
-    item->clip_type = CLIP_TYPE_RECTS;
+    item->clip_type = SPICE_CLIP_TYPE_RECTS;
     region_clone(&item->region, &agent->vis_region);
     red_pipe_add((RedChannel*)channel, (PipeItem *)item);
 }
@@ -2641,7 +2641,7 @@ static void red_create_stream(RedWorker *worker, Drawable *drawable)
     Stream *stream;
     AVFrame *frame;
     uint8_t* frame_buf;
-    Rect* src_rect;
+    SpiceRect* src_rect;
     int stream_width;
     int stream_height;
     int pict_size;
@@ -2694,7 +2694,7 @@ static void red_create_stream(RedWorker *worker, Drawable *drawable)
     stream->frame_buf_end = frame_buf + pict_size;
     QXLImage *qxl_image = (QXLImage *)get_virt(worker, drawable->qxl_drawable->u.copy.src_bitmap,
                                                sizeof(QXLImage), drawable->group_id);
-    stream->top_down = !!(qxl_image->bitmap.flags & BITMAP_TOP_DOWN);
+    stream->top_down = !!(qxl_image->bitmap.flags & SPICE_BITMAP_FLAGS_TOP_DOWN);
     drawable->stream = stream;
 
     if (worker->display_channel) {
@@ -2770,7 +2770,7 @@ static inline int __red_is_next_stream_frame(RedWorker *worker,
                                              const Drawable *candidate,
                                              const int other_src_width,
                                              const int other_src_height,
-                                             const Rect *other_dest,
+                                             const SpiceRect *other_dest,
                                              const red_time_t other_time,
                                              const Stream *stream)
 {
@@ -2787,7 +2787,7 @@ static inline int __red_is_next_stream_frame(RedWorker *worker,
         return FALSE;
     }
 
-    Rect* candidate_src = &qxl_drawable->u.copy.src_area;
+    SpiceRect* candidate_src = &qxl_drawable->u.copy.src_area;
     if (candidate_src->right - candidate_src->left != other_src_width ||
         candidate_src->bottom - candidate_src->top != other_src_height) {
         return FALSE;
@@ -2796,7 +2796,7 @@ static inline int __red_is_next_stream_frame(RedWorker *worker,
     if (stream) {
         QXLImage *qxl_image = (QXLImage *)get_virt(worker, qxl_drawable->u.copy.src_bitmap,
                                                    sizeof(QXLImage), candidate->group_id);
-        if (stream->top_down != !!(qxl_image->bitmap.flags & BITMAP_TOP_DOWN)) {
+        if (stream->top_down != !!(qxl_image->bitmap.flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
             return FALSE;
         }
     }
@@ -2810,7 +2810,7 @@ static inline int red_is_next_stream_frame(RedWorker *worker, const Drawable *ca
         return FALSE;
     }
 
-    Rect* prev_src = &prev->qxl_drawable->u.copy.src_area;
+    SpiceRect* prev_src = &prev->qxl_drawable->u.copy.src_area;
     return __red_is_next_stream_frame(worker, candidate, prev_src->right - prev_src->left,
                                       prev_src->bottom - prev_src->top,
                                       &prev->qxl_drawable->bbox, prev->creation_time,
@@ -2844,19 +2844,19 @@ static inline int red_is_next_stream_frame(RedWorker *worker, Drawable *candidat
         return FALSE;
     }
 
-    if (qxl_drawable->u.copy.rop_decriptor != ROPD_OP_PUT ||
-                                    prev_qxl_drawable->u.copy.rop_decriptor != ROPD_OP_PUT) {
+    if (qxl_drawable->u.copy.rop_decriptor != SPICE_ROPD_OP_PUT ||
+                                    prev_qxl_drawable->u.copy.rop_decriptor != SPICE_ROPD_OP_PUT) {
         return FALSE;
     }
 
     qxl_image = (QXLImage *)get_virt(worker, qxl_drawable->u.copy.src_bitmap, sizeof(QXLImage),
                                      candidate->group_id);
 
-    if (qxl_image->descriptor.type != IMAGE_TYPE_BITMAP) {
+    if (qxl_image->descriptor.type != SPICE_IMAGE_TYPE_BITMAP) {
         return FALSE;
     }
 
-    if (prev->stream && prev->stream->top_down != !!(qxl_image->bitmap.flags & BITMAP_TOP_DOWN)) {
+    if (prev->stream && prev->stream->top_down != !!(qxl_image->bitmap.flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
         return FALSE;
     }
 
@@ -3382,22 +3382,22 @@ static inline int red_current_add(RedWorker *worker, Drawable *drawable)
 
 #endif
 
-static void add_clip_rects(RedWorker *worker, QRegion *rgn, PHYSICAL data, uint32_t group_id)
+static void add_clip_rects(RedWorker *worker, QRegion *rgn, QXLPHYSICAL data, uint32_t group_id)
 {
     while (data) {
         QXLDataChunk *chunk;
-        Rect *now;
-        Rect *end;
+        SpiceRect *now;
+        SpiceRect *end;
         uint32_t data_size;
         chunk = (QXLDataChunk *)get_virt(worker, data, sizeof(QXLDataChunk), group_id);
         data_size = chunk->data_size;
         validate_virt(worker, (unsigned long)chunk->data, get_memslot_id(worker, data), data_size,
                       group_id);
-        now = (Rect *)chunk->data;
-        end = now + data_size / sizeof(Rect);
+        now = (SpiceRect *)chunk->data;
+        end = now + data_size / sizeof(SpiceRect);
 
         for (; now < end; now++) {
-            Rect* r = (Rect *)now;
+            SpiceRect* r = (SpiceRect *)now;
 
             ASSERT(now->top == r->top && now->left == r->left &&
                    now->bottom == r->bottom && now->right == r->right);
@@ -3410,7 +3410,7 @@ static void add_clip_rects(RedWorker *worker, QRegion *rgn, PHYSICAL data, uint3
     }
 }
 
-static inline Shadow *__new_shadow(RedWorker *worker, Drawable *item, Point *delta)
+static inline Shadow *__new_shadow(RedWorker *worker, Drawable *item, SpicePoint *delta)
 {
     if (!delta->x && !delta->y) {
         return NULL;
@@ -3435,7 +3435,7 @@ static inline Shadow *__new_shadow(RedWorker *worker, Drawable *item, Point *del
     return shadow;
 }
 
-static inline int red_current_add_with_shadow(RedWorker *worker, Drawable *item, Point *delta)
+static inline int red_current_add_with_shadow(RedWorker *worker, Drawable *item, SpicePoint *delta)
 {
 #ifdef RED_WORKER_STAT
     stat_time_t start_time = stat_now();
@@ -3497,13 +3497,13 @@ static inline void red_update_streamable(RedWorker *worker, Drawable *drawable,
 
     if (drawable->tree_item.effect != QXL_EFFECT_OPAQUE ||
                                         qxl_drawable->type != QXL_DRAW_COPY ||
-                                        qxl_drawable->u.copy.rop_decriptor != ROPD_OP_PUT) {
+                                        qxl_drawable->u.copy.rop_decriptor != SPICE_ROPD_OP_PUT) {
         return;
     }
 
     qxl_image = (QXLImage *)get_virt(worker, qxl_drawable->u.copy.src_bitmap, sizeof(QXLImage),
                                      drawable->group_id);
-    if (qxl_image->descriptor.type != IMAGE_TYPE_BITMAP) {
+    if (qxl_image->descriptor.type != SPICE_IMAGE_TYPE_BITMAP) {
         return;
     }
 
@@ -3518,7 +3518,7 @@ static inline int red_current_add_qxl(RedWorker *worker, Drawable *drawable,
     int ret;
 
     if (has_shadow(qxl_drawable)) {
-        Point delta;
+        SpicePoint delta;
 
 #ifdef RED_WORKER_STAT
         ++worker->add_with_shadow_count;
@@ -3559,7 +3559,7 @@ static inline int red_current_add_qxl(RedWorker *worker, Drawable *drawable,
     return ret;
 }
 
-static void red_get_area(RedWorker *worker, const Rect *area, uint8_t *dest, int dest_stride,
+static void red_get_area(RedWorker *worker, const SpiceRect *area, uint8_t *dest, int dest_stride,
                          int update)
 {
     if (update) {
@@ -3591,17 +3591,17 @@ static inline int red_handle_self_bitmap(RedWorker *worker, Drawable *drawable)
     }
     dest = (uint8_t *)(image + 1);
 
-    image->descriptor.type = IMAGE_TYPE_BITMAP;
+    image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
     image->descriptor.flags = 0;
 
     QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_RED, ++worker->bits_unique);
     image->bitmap.flags = QXL_BITMAP_DIRECT | (worker->surface.context.top_down ?
                                                QXL_BITMAP_TOP_DOWN : 0);
-    image->bitmap.format = BITMAP_FMT_32BIT;
+    image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
     image->bitmap.stride = dest_stride;
     image->descriptor.width = image->bitmap.x = width;
     image->descriptor.height = image->bitmap.y = height;
-    image->bitmap.data = (PHYSICAL)dest;
+    image->bitmap.data = (QXLPHYSICAL)dest;
     image->bitmap.palette = 0;
 
     red_get_area(worker, &drawable->qxl_drawable->self_bitmap_area, dest, dest_stride, TRUE);
@@ -3677,14 +3677,14 @@ static inline void red_process_drawable(RedWorker *worker, QXLDrawable *drawable
            drawable->bbox.top, drawable->bbox.left, drawable->bbox.bottom, drawable->bbox.right);
 #endif
 
-    if (drawable->clip.type == CLIP_TYPE_RECTS) {
+    if (drawable->clip.type == SPICE_CLIP_TYPE_RECTS) {
         QRegion rgn;
 
         region_init(&rgn);
         add_clip_rects(worker, &rgn, drawable->clip.data + OFFSETOF(QXLClipRects, chunk), group_id);
         region_and(&item->tree_item.base.rgn, &rgn);
         region_destroy(&rgn);
-    } else if (drawable->clip.type == CLIP_TYPE_PATH) {
+    } else if (drawable->clip.type == SPICE_CLIP_TYPE_PATH) {
         item->tree_item.effect = QXL_EFFECT_BLEND;
 #ifdef PIPE_DEBUG
         printf("TEST: DRAWABLE: QXL_CLIP_TYPE_PATH\n");
@@ -3714,7 +3714,7 @@ static inline void red_process_drawable(RedWorker *worker, QXLDrawable *drawable
     release_drawable(worker, item);
 }
 
-static void localize_path(RedWorker *worker, PHYSICAL *in_path, uint32_t group_id)
+static void localize_path(RedWorker *worker, QXLPHYSICAL *in_path, uint32_t group_id)
 {
     QXLPath *path;
     uint8_t *data;
@@ -3726,7 +3726,7 @@ static void localize_path(RedWorker *worker, PHYSICAL *in_path, uint32_t group_i
     path = (QXLPath *)get_virt(worker, *in_path, sizeof(QXLPath), group_id);
     data = malloc(sizeof(UINT32) + path->data_size);
     ASSERT(data);
-    *in_path = (PHYSICAL)data;
+    *in_path = (QXLPHYSICAL)data;
     *(UINT32 *)data = path->data_size;
     data += sizeof(UINT32);
     chunk = &path->chunk;
@@ -3740,18 +3740,18 @@ static void localize_path(RedWorker *worker, PHYSICAL *in_path, uint32_t group_i
     } while (chunk);
 }
 
-static void unlocalize_path(PHYSICAL *path)
+static void unlocalize_path(QXLPHYSICAL *path)
 {
     ASSERT(path && *path);
     free((void *)*path);
     *path = 0;
 }
 
-static void localize_str(RedWorker *worker, PHYSICAL *in_str, uint32_t group_id)
+static void localize_str(RedWorker *worker, QXLPHYSICAL *in_str, uint32_t group_id)
 {
     QXLString *qxl_str = (QXLString *)get_virt(worker, *in_str, sizeof(QXLString), group_id);
     QXLDataChunk *chunk;
-    String *str;
+    SpiceString *str;
     uint8_t *dest;
     uint32_t data_size;
     int memslot_id = get_memslot_id(worker, *in_str);
@@ -3759,13 +3759,13 @@ static void localize_str(RedWorker *worker, PHYSICAL *in_str, uint32_t group_id)
     ASSERT(in_str);
     str = malloc(sizeof(UINT32) + qxl_str->data_size);
     ASSERT(str);
-    *in_str = (PHYSICAL)str;
+    *in_str = (QXLPHYSICAL)str;
     str->length = qxl_str->length;
     str->flags = qxl_str->flags;
     dest = str->data;
     chunk = &qxl_str->chunk;
     for (;;) {
-        PHYSICAL next_chunk;
+        QXLPHYSICAL next_chunk;
 
         data_size = chunk->data_size;
         validate_virt(worker, (unsigned long)chunk->data, memslot_id, data_size, group_id);
@@ -3780,19 +3780,19 @@ static void localize_str(RedWorker *worker, PHYSICAL *in_str, uint32_t group_id)
     }
 }
 
-static void unlocalize_str(PHYSICAL *str)
+static void unlocalize_str(QXLPHYSICAL *str)
 {
     ASSERT(str && *str);
     free((void *)*str);
     *str = 0;
 }
 
-static void localize_clip(RedWorker *worker, Clip *clip, uint32_t group_id)
+static void localize_clip(RedWorker *worker, SpiceClip *clip, uint32_t group_id)
 {
     switch (clip->type) {
-    case CLIP_TYPE_NONE:
+    case SPICE_CLIP_TYPE_NONE:
         return;
-    case CLIP_TYPE_RECTS: {
+    case SPICE_CLIP_TYPE_RECTS: {
         QXLClipRects *clip_rects;
         QXLDataChunk *chunk;
         int memslot_id = get_memslot_id(worker, clip->data);
@@ -3801,9 +3801,9 @@ static void localize_clip(RedWorker *worker, Clip *clip, uint32_t group_id)
         clip_rects = (QXLClipRects *)get_virt(worker, clip->data, sizeof(QXLClipRects), group_id);
         chunk = &clip_rects->chunk;
         ASSERT(clip->data);
-        data = malloc(sizeof(UINT32) + clip_rects->num_rects * sizeof(Rect));
+        data = malloc(sizeof(UINT32) + clip_rects->num_rects * sizeof(SpiceRect));
         ASSERT(data);
-        clip->data = (PHYSICAL)data;
+        clip->data = (QXLPHYSICAL)data;
         *(UINT32 *)(data) = clip_rects->num_rects;
         data += sizeof(UINT32);
         do {
@@ -3817,7 +3817,7 @@ static void localize_clip(RedWorker *worker, Clip *clip, uint32_t group_id)
         } while (chunk);
         break;
     }
-    case CLIP_TYPE_PATH:
+    case SPICE_CLIP_TYPE_PATH:
         localize_path(worker, &clip->data, group_id);
         break;
     default:
@@ -3825,16 +3825,16 @@ static void localize_clip(RedWorker *worker, Clip *clip, uint32_t group_id)
     }
 }
 
-static void unlocalize_clip(Clip *clip)
+static void unlocalize_clip(SpiceClip *clip)
 {
     switch (clip->type) {
-    case CLIP_TYPE_NONE:
+    case SPICE_CLIP_TYPE_NONE:
         return;
-    case CLIP_TYPE_RECTS:
+    case SPICE_CLIP_TYPE_RECTS:
         free((void *)clip->data);
         clip->data = 0;
         break;
-    case CLIP_TYPE_PATH:
+    case SPICE_CLIP_TYPE_PATH:
         unlocalize_path(&clip->data);
         break;
     default:
@@ -3978,7 +3978,7 @@ static void image_cache_eaging(ImageCache *cache)
 #endif
 }
 
-static void localize_bitmap(RedWorker *worker, PHYSICAL *in_bitmap, uint32_t group_id)
+static void localize_bitmap(RedWorker *worker, QXLPHYSICAL *in_bitmap, uint32_t group_id)
 {
     QXLImage *image;
     QXLImage *local_image;
@@ -3987,39 +3987,39 @@ static void localize_bitmap(RedWorker *worker, PHYSICAL *in_bitmap, uint32_t gro
     image = (QXLImage *)get_virt(worker, *in_bitmap, sizeof(QXLImage), group_id);
     local_image = (QXLImage *)alloc_local_image(worker);
     *local_image = *image;
-    *in_bitmap = (PHYSICAL)local_image;
+    *in_bitmap = (QXLPHYSICAL)local_image;
     local_image->descriptor.flags = 0;
 
     if (image_cache_hit(&worker->image_cache, local_image->descriptor.id)) {
-        local_image->descriptor.type = IMAGE_TYPE_FROM_CACHE;
+        local_image->descriptor.type = SPICE_IMAGE_TYPE_FROM_CACHE;
         return;
     }
 
     switch (local_image->descriptor.type) {
-    case IMAGE_TYPE_QUIC: {
+    case SPICE_IMAGE_TYPE_QUIC: {
         QXLDataChunk **chanks_head;
 #ifdef IMAGE_CACHE_AGE
-        local_image->descriptor.flags |= IMAGE_CACHE_ME;
+        local_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
 #else
         if (local_image->descriptor.width * local_image->descriptor.height >= 640 * 480) {
-            local_image->descriptor.flags |= IMAGE_CACHE_ME;
+            local_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
         }
 #endif
         chanks_head = (QXLDataChunk **)local_image->quic.data;
         *chanks_head = (QXLDataChunk *)image->quic.data;
         break;
     }
-    case IMAGE_TYPE_BITMAP:
+    case SPICE_IMAGE_TYPE_BITMAP:
         if (image->bitmap.flags & QXL_BITMAP_DIRECT) {
-            local_image->bitmap.data = (PHYSICAL)get_virt(worker, image->bitmap.data,
+            local_image->bitmap.data = (QXLPHYSICAL)get_virt(worker, image->bitmap.data,
                                                           image->bitmap.stride * image->bitmap.y,
                                                           group_id);
         } else {
-            PHYSICAL src_data;
+            QXLPHYSICAL src_data;
             int size = image->bitmap.y * image->bitmap.stride;
             uint8_t *data = malloc(size);
             ASSERT(data);
-            local_image->bitmap.data = (PHYSICAL)data;
+            local_image->bitmap.data = (QXLPHYSICAL)data;
             src_data = image->bitmap.data;
 
             while (size) {
@@ -4043,12 +4043,12 @@ static void localize_bitmap(RedWorker *worker, PHYSICAL *in_bitmap, uint32_t gro
         if (local_image->bitmap.palette) {
             uint16_t num_ents;
             uint32_t *ents;
-            Palette *tmp_palette;
-            Palette *shadow_palette;
+            SpicePalette *tmp_palette;
+            SpicePalette *shadow_palette;
 
             int slot_id = get_memslot_id(worker, local_image->bitmap.palette);
-            tmp_palette = (Palette *)get_virt(worker, local_image->bitmap.palette,
-                                              sizeof(Palette), group_id);
+            tmp_palette = (SpicePalette *)get_virt(worker, local_image->bitmap.palette,
+                                              sizeof(SpicePalette), group_id);
 
             num_ents = tmp_palette->num_ents;
             ents = tmp_palette->ents;
@@ -4056,17 +4056,17 @@ static void localize_bitmap(RedWorker *worker, PHYSICAL *in_bitmap, uint32_t gro
             validate_virt(worker, (unsigned long)ents, slot_id, (num_ents * sizeof(uint32_t)),
                           group_id);
 
-            shadow_palette = (Palette *)malloc(sizeof(Palette) + num_ents * sizeof(uint32_t) +
-                                               sizeof(PHYSICAL));
+            shadow_palette = (SpicePalette *)malloc(sizeof(SpicePalette) + num_ents * sizeof(uint32_t) +
+                                               sizeof(QXLPHYSICAL));
             if (!shadow_palette) {
-                PANIC("Palette malloc failed");
+                PANIC("SpicePalette malloc failed");
             }
 
             memcpy(shadow_palette->ents, ents, num_ents * sizeof(uint32_t));
             shadow_palette->num_ents = num_ents;
             shadow_palette->unique = tmp_palette->unique;
 
-            local_image->bitmap.palette = (ADDRESS)shadow_palette;
+            local_image->bitmap.palette = (SPICE_ADDRESS)shadow_palette;
         }
         break;
     default:
@@ -4074,7 +4074,7 @@ static void localize_bitmap(RedWorker *worker, PHYSICAL *in_bitmap, uint32_t gro
     }
 }
 
-static void unlocalize_bitmap(PHYSICAL *bitmap)
+static void unlocalize_bitmap(QXLPHYSICAL *bitmap)
 {
     QXLImage *image;
 
@@ -4083,7 +4083,7 @@ static void unlocalize_bitmap(PHYSICAL *bitmap)
     *bitmap = 0;
 
     switch (image->descriptor.type) {
-    case IMAGE_TYPE_BITMAP:
+    case SPICE_IMAGE_TYPE_BITMAP:
         if (!(image->bitmap.flags & QXL_BITMAP_DIRECT)) {
             free((void *)image->bitmap.data);
         }
@@ -4091,8 +4091,8 @@ static void unlocalize_bitmap(PHYSICAL *bitmap)
             free((void *)image->bitmap.palette);
         }
         break;
-    case IMAGE_TYPE_QUIC:
-    case IMAGE_TYPE_FROM_CACHE:
+    case SPICE_IMAGE_TYPE_QUIC:
+    case SPICE_IMAGE_TYPE_FROM_CACHE:
         *bitmap = 0;
         break;
     default:
@@ -4100,35 +4100,35 @@ static void unlocalize_bitmap(PHYSICAL *bitmap)
     }
 }
 
-static void localize_brush(RedWorker *worker, Brush *brush, uint32_t group_id)
+static void localize_brush(RedWorker *worker, SpiceBrush *brush, uint32_t group_id)
 {
-    if (brush->type == BRUSH_TYPE_PATTERN) {
+    if (brush->type == SPICE_BRUSH_TYPE_PATTERN) {
         localize_bitmap(worker, &brush->u.pattern.pat, group_id);
     }
 }
 
-static void unlocalize_brush(Brush *brush)
+static void unlocalize_brush(SpiceBrush *brush)
 {
-    if (brush->type == BRUSH_TYPE_PATTERN) {
+    if (brush->type == SPICE_BRUSH_TYPE_PATTERN) {
         unlocalize_bitmap(&brush->u.pattern.pat);
     }
 }
 
-static void localize_mask(RedWorker *worker, QMask *mask, uint32_t group_id)
+static void localize_mask(RedWorker *worker, SpiceQMask *mask, uint32_t group_id)
 {
     if (mask->bitmap) {
         localize_bitmap(worker, &mask->bitmap, group_id);
     }
 }
 
-static void unlocalize_mask(QMask *mask)
+static void unlocalize_mask(SpiceQMask *mask)
 {
     if (mask->bitmap) {
         unlocalize_bitmap(&mask->bitmap);
     }
 }
 
-static void localize_attr(RedWorker *worker, LineAttr *attr, uint32_t group_id)
+static void localize_attr(RedWorker *worker, SpiceLineAttr *attr, uint32_t group_id)
 {
     if (attr->style_nseg) {
         uint8_t *buf;
@@ -4140,11 +4140,11 @@ static void localize_attr(RedWorker *worker, LineAttr *attr, uint32_t group_id)
         data = malloc(attr->style_nseg * sizeof(uint32_t));
         ASSERT(data);
         memcpy(data, buf, attr->style_nseg * sizeof(uint32_t));
-        attr->style = (PHYSICAL)data;
+        attr->style = (QXLPHYSICAL)data;
     }
 }
 
-static void unlocalize_attr(LineAttr *attr)
+static void unlocalize_attr(SpiceLineAttr *attr)
 {
     if (attr->style_nseg) {
         free((void *)attr->style);
@@ -4154,7 +4154,7 @@ static void unlocalize_attr(LineAttr *attr)
 
 static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
 {
-    Clip clip = drawable->qxl_drawable->clip;
+    SpiceClip clip = drawable->qxl_drawable->clip;
 
     worker->local_images_pos = 0;
     image_cache_eaging(&worker->image_cache);
@@ -4164,7 +4164,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
     localize_clip(worker, &clip, drawable->group_id);
     switch (drawable->qxl_drawable->type) {
     case QXL_DRAW_FILL: {
-        Fill fill = drawable->qxl_drawable->u.fill;
+        SpiceFill fill = drawable->qxl_drawable->u.fill;
         localize_brush(worker, &fill.brush, drawable->group_id);
         localize_mask(worker, &fill.mask, drawable->group_id);
         worker->draw_funcs.draw_fill(worker->surface.context.canvas, &drawable->qxl_drawable->bbox,
@@ -4173,7 +4173,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_OPAQUE: {
-        Opaque opaque = drawable->qxl_drawable->u.opaque;
+        SpiceOpaque opaque = drawable->qxl_drawable->u.opaque;
         localize_brush(worker, &opaque.brush, drawable->group_id);
         localize_bitmap(worker, &opaque.src_bitmap, drawable->group_id);
         localize_mask(worker, &opaque.mask, drawable->group_id);
@@ -4185,7 +4185,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_COPY: {
-        Copy copy = drawable->qxl_drawable->u.copy;
+        SpiceCopy copy = drawable->qxl_drawable->u.copy;
         localize_bitmap(worker, &copy.src_bitmap, drawable->group_id);
         localize_mask(worker, &copy.mask, drawable->group_id);
         worker->draw_funcs.draw_copy(worker->surface.context.canvas, &drawable->qxl_drawable->bbox,
@@ -4195,7 +4195,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_TRANSPARENT: {
-        Transparent transparent = drawable->qxl_drawable->u.transparent;
+        SpiceTransparent transparent = drawable->qxl_drawable->u.transparent;
         localize_bitmap(worker, &transparent.src_bitmap, drawable->group_id);
         worker->draw_funcs.draw_transparent(worker->surface.context.canvas,
                                             &drawable->qxl_drawable->bbox, &clip, &transparent);
@@ -4203,7 +4203,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_ALPHA_BLEND: {
-        AlphaBlnd alpha_blend = drawable->qxl_drawable->u.alpha_blend;
+        SpiceAlphaBlnd alpha_blend = drawable->qxl_drawable->u.alpha_blend;
         localize_bitmap(worker, &alpha_blend.src_bitmap, drawable->group_id);
         worker->draw_funcs.draw_alpha_blend(worker->surface.context.canvas,
                                             &drawable->qxl_drawable->bbox, &clip, &alpha_blend);
@@ -4216,7 +4216,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_BLEND: {
-        Blend blend = drawable->qxl_drawable->u.blend;
+        SpiceBlend blend = drawable->qxl_drawable->u.blend;
         localize_bitmap(worker, &blend.src_bitmap, drawable->group_id);
         localize_mask(worker, &blend.mask, drawable->group_id);
         worker->draw_funcs.draw_blend(worker->surface.context.canvas, &drawable->qxl_drawable->bbox,
@@ -4226,7 +4226,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_BLACKNESS: {
-        Blackness blackness = drawable->qxl_drawable->u.blackness;
+        SpiceBlackness blackness = drawable->qxl_drawable->u.blackness;
         localize_mask(worker, &blackness.mask, drawable->group_id);
         worker->draw_funcs.draw_blackness(worker->surface.context.canvas,
                                           &drawable->qxl_drawable->bbox, &clip, &blackness);
@@ -4234,7 +4234,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_WHITENESS: {
-        Whiteness whiteness = drawable->qxl_drawable->u.whiteness;
+        SpiceWhiteness whiteness = drawable->qxl_drawable->u.whiteness;
         localize_mask(worker, &whiteness.mask, drawable->group_id);
         worker->draw_funcs.draw_whiteness(worker->surface.context.canvas,
                                           &drawable->qxl_drawable->bbox, &clip, &whiteness);
@@ -4242,7 +4242,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_INVERS: {
-        Invers invers = drawable->qxl_drawable->u.invers;
+        SpiceInvers invers = drawable->qxl_drawable->u.invers;
         localize_mask(worker, &invers.mask, drawable->group_id);
         worker->draw_funcs.draw_invers(worker->surface.context.canvas,
                                        &drawable->qxl_drawable->bbox, &clip, &invers);
@@ -4250,7 +4250,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_ROP3: {
-        Rop3 rop3 = drawable->qxl_drawable->u.rop3;
+        SpiceRop3 rop3 = drawable->qxl_drawable->u.rop3;
         localize_brush(worker, &rop3.brush, drawable->group_id);
         localize_bitmap(worker, &rop3.src_bitmap, drawable->group_id);
         localize_mask(worker, &rop3.mask, drawable->group_id);
@@ -4261,7 +4261,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_STROKE: {
-        Stroke stroke = drawable->qxl_drawable->u.stroke;
+        SpiceStroke stroke = drawable->qxl_drawable->u.stroke;
         localize_brush(worker, &stroke.brush, drawable->group_id);
         localize_path(worker, &stroke.path, drawable->group_id);
         localize_attr(worker, &stroke.attr, drawable->group_id);
@@ -4273,7 +4273,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     case QXL_DRAW_TEXT: {
-        Text text = drawable->qxl_drawable->u.text;
+        SpiceText text = drawable->qxl_drawable->u.text;
         localize_brush(worker, &text.fore_brush, drawable->group_id);
         localize_brush(worker, &text.back_brush, drawable->group_id);
         localize_str(worker, &text.str, drawable->group_id);
@@ -4355,7 +4355,7 @@ static inline void __red_collect_for_update(RedWorker *worker, Ring *ring, RingI
     }
 }
 
-static void red_update_area(RedWorker *worker, const Rect *area)
+static void red_update_area(RedWorker *worker, const SpiceRect *area)
 {
     Ring *ring = &worker->current;
     RingItem *ring_item;
@@ -4390,7 +4390,7 @@ static void red_update_area(RedWorker *worker, const Rect *area)
 
 #else
 
-static void red_update_area(RedWorker *worker, const Rect *area)
+static void red_update_area(RedWorker *worker, const SpiceRect *area)
 {
     Ring *ring = &worker->current_list;
     RingItem *ring_item = ring;
@@ -4533,7 +4533,7 @@ void qxl_process_cursor(RedWorker *worker, QXLCursorCmd *cursor_cmd, uint32_t gr
         red_error("invalid cursor command %u", cursor_cmd->type);
     }
 
-    if (worker->cursor_channel && (worker->mouse_mode == RED_MOUSE_MODE_SERVER ||
+    if (worker->cursor_channel && (worker->mouse_mode == SPICE_MOUSE_MODE_SERVER ||
                                    cursor_cmd->type != QXL_CURSOR_MOVE || cursor_show)) {
         red_pipe_add(&worker->cursor_channel->base, &item->pipe_data);
     } else {
@@ -4684,7 +4684,7 @@ static void red_add_screen_image(RedWorker *worker)
 {
     ImageItem *item;
     int stride;
-    Rect area;
+    SpiceRect area;
 
     if (!worker->display_channel || !worker->surface.context.canvas) {
         return;
@@ -4734,7 +4734,7 @@ static void add_buf(RedChannel *channel, uint32_t type, void *data, uint32_t siz
     channel->send_data.header.size += size;
 }
 
-static void fill_path(DisplayChannel *display_channel, PHYSICAL *in_path, uint32_t group_id)
+static void fill_path(DisplayChannel *display_channel, QXLPHYSICAL *in_path, uint32_t group_id)
 {
     RedWorker *worker;
     RedChannel *channel = &display_channel->base;
@@ -4748,7 +4748,7 @@ static void fill_path(DisplayChannel *display_channel, PHYSICAL *in_path, uint32
     add_buf(channel, BUF_TYPE_CHUNK, &path->chunk, path->data_size, memslot_id, group_id);
 }
 
-static void fill_str(DisplayChannel *display_channel, PHYSICAL *in_str, uint32_t group_id)
+static void fill_str(DisplayChannel *display_channel, QXLPHYSICAL *in_str, uint32_t group_id)
 {
     RedWorker *worker;
     RedChannel *channel = &display_channel->base;
@@ -4762,7 +4762,7 @@ static void fill_str(DisplayChannel *display_channel, PHYSICAL *in_str, uint32_t
     add_buf(channel, BUF_TYPE_CHUNK, &str->chunk, str->data_size, memslot_id, group_id);
 }
 
-static inline void fill_rects_clip(RedChannel *channel, PHYSICAL *in_clip, uint32_t group_id)
+static inline void fill_rects_clip(RedChannel *channel, QXLPHYSICAL *in_clip, uint32_t group_id)
 {
     RedWorker *worker = channel->worker;
     QXLClipRects *clip;
@@ -4772,11 +4772,11 @@ static inline void fill_rects_clip(RedChannel *channel, PHYSICAL *in_clip, uint3
     clip = (QXLClipRects *)get_virt(worker, *in_clip, sizeof(QXLClipRects), group_id);
     *in_clip = channel->send_data.header.size;
     add_buf(channel, BUF_TYPE_RAW, &clip->num_rects, sizeof(UINT32), 0, 0);
-    add_buf(channel, BUF_TYPE_CHUNK, &clip->chunk, clip->num_rects * sizeof(Rect), memslot_id,
+    add_buf(channel, BUF_TYPE_CHUNK, &clip->chunk, clip->num_rects * sizeof(SpiceRect), memslot_id,
             group_id);
 }
 
-static void fill_base(DisplayChannel *display_channel, RedDrawBase *base, Drawable *drawable,
+static void fill_base(DisplayChannel *display_channel, SpiceMsgDisplayBase *base, Drawable *drawable,
                       uint32_t size)
 {
     RedChannel *channel = &display_channel->base;
@@ -4784,9 +4784,9 @@ static void fill_base(DisplayChannel *display_channel, RedDrawBase *base, Drawab
     base->box = drawable->qxl_drawable->bbox;
     base->clip = drawable->qxl_drawable->clip;
 
-    if (base->clip.type == CLIP_TYPE_RECTS) {
+    if (base->clip.type == SPICE_CLIP_TYPE_RECTS) {
         fill_rects_clip(channel, &base->clip.data, drawable->group_id);
-    } else if (base->clip.type == CLIP_TYPE_PATH) {
+    } else if (base->clip.type == SPICE_CLIP_TYPE_PATH) {
         fill_path(display_channel, &base->clip.data, drawable->group_id);
     }
 }
@@ -4798,30 +4798,30 @@ static inline RedImage *alloc_image(DisplayChannel *display_channel)
 }
 
 /* io_palette is relative address of the palette*/
-static inline void fill_palette(DisplayChannel *display_channel, ADDRESS *io_palette, UINT8 *flags,
+static inline void fill_palette(DisplayChannel *display_channel, SPICE_ADDRESS *io_palette, UINT8 *flags,
                                 uint32_t group_id)
 {
     RedChannel *channel = &display_channel->base;
     RedWorker *worker = channel->worker;
-    Palette *palette;
+    SpicePalette *palette;
 
     if (!(*io_palette)) {
         return;
     }
-    palette = (Palette *)get_virt(worker, *io_palette, sizeof(Palette), group_id);
+    palette = (SpicePalette *)get_virt(worker, *io_palette, sizeof(SpicePalette), group_id);
     if (palette->unique) {
         if (red_palette_cache_find(display_channel, palette->unique)) {
-            *flags |= BITMAP_PAL_FROM_CACHE;
+            *flags |= SPICE_BITMAP_FLAGS_PAL_FROM_CACHE;
             *io_palette = palette->unique;
             return;
         }
         if (red_palette_cache_add(display_channel, palette->unique, 1)) {
-            *flags |= BITMAP_PAL_CACHE_ME;
+            *flags |= SPICE_BITMAP_FLAGS_PAL_CACHE_ME;
         }
     }
     *io_palette = channel->send_data.header.size;
     add_buf(channel, BUF_TYPE_RAW, palette,
-            sizeof(Palette) + palette->num_ents * sizeof(UINT32), 0, 0);
+            sizeof(SpicePalette) + palette->num_ents * sizeof(UINT32), 0, 0);
 }
 
 static inline RedCompressBuf *red_display_alloc_compress_buf(DisplayChannel *display_channel)
@@ -5425,7 +5425,7 @@ typedef uint16_t rgb16_pixel_t;
 #define GRADUAL_SCORE_RGB16_TH 0
 
 // assumes that stride doesn't overflow
-static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap, uint32_t group_id)
+static int _bitmap_is_gradual(RedWorker *worker, SpiceBitmap *bitmap, uint32_t group_id)
 {
     double score = 0.0;
     int num_samples = 0;
@@ -5437,20 +5437,20 @@ static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap, uint32_t group_
         x = bitmap->x;
         y = bitmap->y;
         switch (bitmap->format) {
-        case BITMAP_FMT_16BIT: {
+        case SPICE_BITMAP_FMT_16BIT: {
             uint8_t *lines = (uint8_t*)get_virt(worker, bitmap->data, x * y *
                                                 sizeof(rgb16_pixel_t), group_id);
             compute_lines_gradual_score_rgb16((rgb16_pixel_t*)lines, x, y, &score, &num_samples);
             break;
         }
-        case BITMAP_FMT_24BIT: {
+        case SPICE_BITMAP_FMT_24BIT: {
             uint8_t *lines = (uint8_t*)get_virt(worker, bitmap->data, x * y *
                                                 sizeof(rgb24_pixel_t), group_id);
             compute_lines_gradual_score_rgb24((rgb24_pixel_t*)lines, x, y, &score, &num_samples);
             break;
         }
-        case BITMAP_FMT_32BIT:
-        case BITMAP_FMT_RGBA: {
+        case SPICE_BITMAP_FMT_32BIT:
+        case SPICE_BITMAP_FMT_RGBA: {
             uint8_t *lines = (uint8_t*)get_virt(worker, bitmap->data, x * y *
                                                 sizeof(rgb32_pixel_t), group_id);
             compute_lines_gradual_score_rgb32((rgb32_pixel_t*)lines, x, y, &score, &num_samples);
@@ -5465,7 +5465,7 @@ static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap, uint32_t group_
         double chunk_score = 0.0;
         int chunk_num_samples = 0;
         uint32_t x;
-        ADDRESS relative_address = bitmap->data;
+        SPICE_ADDRESS relative_address = bitmap->data;
 
         while (relative_address) {
             chunk = (QXLDataChunk *)get_virt(worker, relative_address, sizeof(QXLDataChunk),
@@ -5473,22 +5473,22 @@ static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap, uint32_t group_
             num_lines = chunk->data_size / bitmap->stride;
             x = bitmap->x;
             switch (bitmap->format) {
-            case BITMAP_FMT_16BIT:
+            case SPICE_BITMAP_FMT_16BIT:
                 validate_virt(worker, (unsigned long)chunk->data,
                               get_memslot_id(worker, relative_address),
                               sizeof(rgb16_pixel_t) * x * num_lines, group_id);
                 compute_lines_gradual_score_rgb16((rgb16_pixel_t*)chunk->data, x, num_lines,
                                                   &chunk_score, &chunk_num_samples);
                 break;
-            case BITMAP_FMT_24BIT:
+            case SPICE_BITMAP_FMT_24BIT:
                 validate_virt(worker, (unsigned long)chunk->data,
                               get_memslot_id(worker, relative_address),
                               sizeof(rgb24_pixel_t) * x * num_lines, group_id);
                 compute_lines_gradual_score_rgb24((rgb24_pixel_t*)chunk->data, x, num_lines,
                                                   &chunk_score, &chunk_num_samples);
                 break;
-            case BITMAP_FMT_32BIT:
-            case BITMAP_FMT_RGBA:
+            case SPICE_BITMAP_FMT_32BIT:
+            case SPICE_BITMAP_FMT_RGBA:
                 validate_virt(worker, (unsigned long)chunk->data,
                               get_memslot_id(worker, relative_address),
                               sizeof(rgb32_pixel_t) *  x * num_lines, group_id);
@@ -5509,29 +5509,29 @@ static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap, uint32_t group_
     ASSERT(num_samples);
     score /= num_samples;
 
-    if (bitmap->format == BITMAP_FMT_16BIT) {
+    if (bitmap->format == SPICE_BITMAP_FMT_16BIT) {
         return (score < GRADUAL_SCORE_RGB16_TH);
     } else {
         return (score < GRADUAL_SCORE_RGB24_TH);
     }
 }
 
-static inline int _stride_is_extra(Bitmap *bitmap)
+static inline int _stride_is_extra(SpiceBitmap *bitmap)
 {
     ASSERT(bitmap);
     if (BITMAP_FMT_IS_RGB[bitmap->format]) {
         return ((bitmap->x * BITMAP_FMP_BYTES_PER_PIXEL[bitmap->format]) < bitmap->stride);
     } else {
         switch (bitmap->format) {
-        case BITMAP_FMT_8BIT:
+        case SPICE_BITMAP_FMT_8BIT:
             return (bitmap->x < bitmap->stride);
-        case BITMAP_FMT_4BIT_BE:
-        case BITMAP_FMT_4BIT_LE: {
+        case SPICE_BITMAP_FMT_4BIT_BE:
+        case SPICE_BITMAP_FMT_4BIT_LE: {
             int bytes_width = ALIGN(bitmap->x, 2) >> 1;
             return bytes_width < bitmap->stride;
         }
-        case BITMAP_FMT_1BIT_BE:
-        case BITMAP_FMT_1BIT_LE: {
+        case SPICE_BITMAP_FMT_1BIT_BE:
+        case SPICE_BITMAP_FMT_1BIT_LE: {
             int bytes_width = ALIGN(bitmap->x, 8) >> 3;
             return bytes_width < bitmap->stride;
         }
@@ -5558,13 +5558,13 @@ typedef struct compress_send_data_t {
     uint32_t raw_size;
     void*    comp_buf;
     uint32_t comp_buf_size;
-    ADDRESS  *plt_ptr;
+    SPICE_ADDRESS  *plt_ptr;
     UINT8    *flags_ptr;
 } compress_send_data_t;
 
 
 static inline int red_glz_compress_image(DisplayChannel *display_channel,
-                                         RedImage *dest, Bitmap *src, Drawable *drawable,
+                                         RedImage *dest, SpiceBitmap *src, Drawable *drawable,
                                          compress_send_data_t* o_comp_data)
 {
     RedWorker *worker = (RedWorker *)display_channel->base.worker;
@@ -5617,10 +5617,10 @@ static inline int red_glz_compress_image(DisplayChannel *display_channel,
                       glz_drawable_instance,
                       &glz_drawable_instance->glz_instance);
 
-    dest->descriptor.type = IMAGE_TYPE_GLZ_RGB;
+    dest->descriptor.type = SPICE_IMAGE_TYPE_GLZ_RGB;
     dest->lz_rgb.data_size = size;
 
-    o_comp_data->raw_size = sizeof(LZ_RGBImage);
+    o_comp_data->raw_size = sizeof(SpiceLZRGBImage);
     o_comp_data->comp_buf = glz_data->data.bufs_head;
     o_comp_data->comp_buf_size = size;
     o_comp_data->plt_ptr = NULL;
@@ -5632,7 +5632,7 @@ static inline int red_glz_compress_image(DisplayChannel *display_channel,
 }
 
 static inline int red_lz_compress_image(DisplayChannel *display_channel,
-                                        RedImage *dest, Bitmap *src,
+                                        RedImage *dest, SpiceBitmap *src,
                                         compress_send_data_t* o_comp_data, uint32_t group_id)
 {
     RedWorker *worker = display_channel->base.worker;
@@ -5692,21 +5692,21 @@ static inline int red_lz_compress_image(DisplayChannel *display_channel,
     }
 
     if (BITMAP_FMT_IS_RGB[src->format]) {
-        dest->descriptor.type = IMAGE_TYPE_LZ_RGB;
+        dest->descriptor.type = SPICE_IMAGE_TYPE_LZ_RGB;
         dest->lz_rgb.data_size = size;
 
-        o_comp_data->raw_size = sizeof(LZ_RGBImage);
+        o_comp_data->raw_size = sizeof(SpiceLZRGBImage);
         o_comp_data->comp_buf = lz_data->data.bufs_head;
         o_comp_data->comp_buf_size = size;
         o_comp_data->plt_ptr = NULL;
         o_comp_data->flags_ptr = NULL;
     } else {
-        dest->descriptor.type = IMAGE_TYPE_LZ_PLT;
+        dest->descriptor.type = SPICE_IMAGE_TYPE_LZ_PLT;
         dest->lz_plt.data_size = size;
-        dest->lz_plt.flags = src->flags & BITMAP_TOP_DOWN;
+        dest->lz_plt.flags = src->flags & SPICE_BITMAP_FLAGS_TOP_DOWN;
         dest->lz_plt.palette = src->palette;
 
-        o_comp_data->raw_size = sizeof(LZ_PLTImage);
+        o_comp_data->raw_size = sizeof(SpiceLZPLTImage);
         o_comp_data->comp_buf = lz_data->data.bufs_head;
         o_comp_data->comp_buf_size = size;
         o_comp_data->plt_ptr = &(dest->lz_plt.palette);
@@ -5718,7 +5718,7 @@ static inline int red_lz_compress_image(DisplayChannel *display_channel,
 }
 
 static inline int red_quic_compress_image(DisplayChannel *display_channel, RedImage *dest,
-                                          Bitmap *src, compress_send_data_t* o_comp_data,
+                                          SpiceBitmap *src, compress_send_data_t* o_comp_data,
                                           uint32_t group_id)
 {
     RedWorker *worker = display_channel->base.worker;
@@ -5732,16 +5732,16 @@ static inline int red_quic_compress_image(DisplayChannel *display_channel, RedIm
 #endif
 
     switch (src->format) {
-    case BITMAP_FMT_32BIT:
+    case SPICE_BITMAP_FMT_32BIT:
         type = QUIC_IMAGE_TYPE_RGB32;
         break;
-    case BITMAP_FMT_RGBA:
+    case SPICE_BITMAP_FMT_RGBA:
         type = QUIC_IMAGE_TYPE_RGBA;
         break;
-    case BITMAP_FMT_16BIT:
+    case SPICE_BITMAP_FMT_16BIT:
         type = QUIC_IMAGE_TYPE_RGB16;
         break;
-    case BITMAP_FMT_24BIT:
+    case SPICE_BITMAP_FMT_24BIT:
         type = QUIC_IMAGE_TYPE_RGB24;
         break;
     default:
@@ -5824,7 +5824,7 @@ static inline int red_quic_compress_image(DisplayChannel *display_channel, RedIm
             quic_data->usr.more_lines = quic_usr_more_lines;
             stride = src->stride;
         } else {
-            ADDRESS prev_addr = src->data;
+            SPICE_ADDRESS prev_addr = src->data;
             QXLDataChunk *chunk = (QXLDataChunk *)get_virt(worker, src->data,
                                                            sizeof(QXLDataChunk), group_id);
             while (chunk->next_chunk) {
@@ -5833,7 +5833,7 @@ static inline int red_quic_compress_image(DisplayChannel *display_channel, RedIm
                                                  group_id);
                 ASSERT(chunk->prev_chunk);
             }
-            quic_data->data.u.lines_data.next = (ADDRESS)prev_addr -
+            quic_data->data.u.lines_data.next = (SPICE_ADDRESS)prev_addr -
                                                 get_virt_delta(worker,
                                                                get_memslot_id(worker, src->data),
                                                                group_id);
@@ -5850,10 +5850,10 @@ static inline int red_quic_compress_image(DisplayChannel *display_channel, RedIm
         longjmp(quic_data->data.jmp_env, 1);
     }
 
-    dest->descriptor.type = IMAGE_TYPE_QUIC;
+    dest->descriptor.type = SPICE_IMAGE_TYPE_QUIC;
     dest->quic.data_size = size << 2;
 
-    o_comp_data->raw_size = sizeof(QUICImage);
+    o_comp_data->raw_size = sizeof(SpiceQUICImage);
     o_comp_data->comp_buf = quic_data->data.bufs_head;
     o_comp_data->comp_buf_size = size << 2;
     o_comp_data->plt_ptr = NULL;
@@ -5867,7 +5867,7 @@ static inline int red_quic_compress_image(DisplayChannel *display_channel, RedIm
 #define MIN_SIZE_TO_COMPRESS 54
 #define MIN_DIMENSION_TO_QUIC 3
 static inline int red_compress_image(DisplayChannel *display_channel,
-                                     RedImage *dest, Bitmap *src, Drawable *drawable,
+                                     RedImage *dest, SpiceBitmap *src, Drawable *drawable,
                                      compress_send_data_t* o_comp_data)
 {
     image_compression_t image_compression = display_channel->base.worker->image_compression;
@@ -5971,19 +5971,19 @@ static inline void red_display_add_image_to_pixmap_cache(DisplayChannel *display
         if (pixmap_cache_add(display_channel->pixmap_cache, qxl_image->descriptor.id,
                              qxl_image->descriptor.width * qxl_image->descriptor.height,
                              display_channel)) {
-            io_image->descriptor.flags |= IMAGE_CACHE_ME;
+            io_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
             stat_inc_counter(display_channel->add_to_cache_counter, 1);
         }
     }
 
-    if (!(io_image->descriptor.flags & IMAGE_CACHE_ME)) {
+    if (!(io_image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) {
         stat_inc_counter(display_channel->non_cache_counter, 1);
     }
 }
 
 /* if the number of times fill_bits can be called per one qxl_drawable increases -
    MAX_LZ_DRAWABLE_INSTANCES must be increased as well */
-static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Drawable *drawable)
+static void fill_bits(DisplayChannel *display_channel, QXLPHYSICAL *in_bitmap, Drawable *drawable)
 {
     RedChannel *channel = &display_channel->base;
     RedWorker *worker = channel->worker;
@@ -6009,15 +6009,15 @@ static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Draw
     if ((qxl_image->descriptor.flags & QXL_IMAGE_CACHE)) {
         if (pixmap_cache_hit(display_channel->pixmap_cache, image->descriptor.id,
                              display_channel)) {
-            image->descriptor.type = IMAGE_TYPE_FROM_CACHE;
-            add_buf(channel, BUF_TYPE_RAW, image, sizeof(ImageDescriptor), 0, 0);
+            image->descriptor.type = SPICE_IMAGE_TYPE_FROM_CACHE;
+            add_buf(channel, BUF_TYPE_RAW, image, sizeof(SpiceImageDescriptor), 0, 0);
             stat_inc_counter(display_channel->cache_hits_counter, 1);
             return;
         }
     }
 
     switch (qxl_image->descriptor.type) {
-    case IMAGE_TYPE_BITMAP:
+    case SPICE_IMAGE_TYPE_BITMAP:
 #ifdef DUMP_BITMAP
         dump_bitmap(display_channel->base.worker, &qxl_image->bitmap, drawable->group_id);
 #endif
@@ -6028,7 +6028,7 @@ static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Draw
                                 drawable, &comp_send_data)) {
             uint32_t y;
             uint32_t stride;
-            ADDRESS image_data;
+            SPICE_ADDRESS image_data;
 
             red_display_add_image_to_pixmap_cache(display_channel, qxl_image, image);
 
@@ -6036,9 +6036,9 @@ static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Draw
             y = image->bitmap.y;
             stride = image->bitmap.stride;
             image_data = image->bitmap.data;
-            image->bitmap.flags = image->bitmap.flags & BITMAP_TOP_DOWN;
+            image->bitmap.flags = image->bitmap.flags & SPICE_BITMAP_FLAGS_TOP_DOWN;
 
-            add_buf(channel, BUF_TYPE_RAW, image, sizeof(BitmapImage), 0, 0);
+            add_buf(channel, BUF_TYPE_RAW, image, sizeof(SpiceBitmapImage), 0, 0);
             fill_palette(display_channel, &(image->bitmap.palette), &(image->bitmap.flags),
                          drawable->group_id);
             image->bitmap.data = channel->send_data.header.size;
@@ -6064,10 +6064,10 @@ static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Draw
             }
         }
         break;
-    case IMAGE_TYPE_QUIC:
+    case SPICE_IMAGE_TYPE_QUIC:
         red_display_add_image_to_pixmap_cache(display_channel, qxl_image, image);
         image->quic = qxl_image->quic;
-        add_buf(channel, BUF_TYPE_RAW, image, sizeof(QUICImage), 0, 0);
+        add_buf(channel, BUF_TYPE_RAW, image, sizeof(SpiceQUICImage), 0, 0);
         add_buf(channel, BUF_TYPE_CHUNK, qxl_image->quic.data, qxl_image->quic.data_size,
                 memslot_id, drawable->group_id);
         break;
@@ -6076,14 +6076,14 @@ static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Draw
     }
 }
 
-static void fill_brush(DisplayChannel *display_channel, Brush *brush, Drawable *drawable)
+static void fill_brush(DisplayChannel *display_channel, SpiceBrush *brush, Drawable *drawable)
 {
-    if (brush->type == BRUSH_TYPE_PATTERN) {
+    if (brush->type == SPICE_BRUSH_TYPE_PATTERN) {
         fill_bits(display_channel, &brush->u.pattern.pat, drawable);
     }
 }
 
-static void fill_mask(DisplayChannel *display_channel, QMask *mask, Drawable *drawable)
+static void fill_mask(DisplayChannel *display_channel, SpiceQMask *mask, Drawable *drawable)
 {
     if (mask->bitmap) {
         if (display_channel->base.worker->image_compression != IMAGE_COMPRESS_OFF) {
@@ -6097,7 +6097,7 @@ static void fill_mask(DisplayChannel *display_channel, QMask *mask, Drawable *dr
     }
 }
 
-static void fill_attr(DisplayChannel *display_channel, LineAttr *attr, uint32_t group_id)
+static void fill_attr(DisplayChannel *display_channel, SpiceLineAttr *attr, uint32_t group_id)
 {
     if (attr->style_nseg) {
         RedChannel *channel = &display_channel->base;
@@ -6109,12 +6109,12 @@ static void fill_attr(DisplayChannel *display_channel, LineAttr *attr, uint32_t
     }
 }
 
-static void fill_cursor(CursorChannel *cursor_channel, RedCursor *red_cursor, CursorItem *cursor)
+static void fill_cursor(CursorChannel *cursor_channel, SpiceCursor *red_cursor, CursorItem *cursor)
 {
     RedChannel *channel = &cursor_channel->base;
 
     if (!cursor) {
-        red_cursor->flags = RED_CURSOR_NONE;
+        red_cursor->flags = SPICE_CURSOR_FLAGS_NONE;
         return;
     }
 
@@ -6130,11 +6130,11 @@ static void fill_cursor(CursorChannel *cursor_channel, RedCursor *red_cursor, Cu
 
         if (red_cursor->header.unique) {
             if (red_cursor_cache_find(cursor_channel, red_cursor->header.unique)) {
-                red_cursor->flags |= RED_CURSOR_FROM_CACHE;
+                red_cursor->flags |= SPICE_CURSOR_FLAGS_FROM_CACHE;
                 return;
             }
             if (red_cursor_cache_add(cursor_channel, red_cursor->header.unique, 1)) {
-                red_cursor->flags |= RED_CURSOR_CACHE_ME;
+                red_cursor->flags |= SPICE_CURSOR_FLAGS_CACHE_ME;
             }
         }
 
@@ -6160,7 +6160,7 @@ static inline void red_channel_reset_send_data(RedChannel *channel)
     channel->send_data.header.sub_list = 0;
     ++channel->send_data.header.serial;
     channel->send_data.bufs[0].type = BUF_TYPE_RAW;
-    channel->send_data.bufs[0].size = sizeof(RedDataHeader);
+    channel->send_data.bufs[0].size = sizeof(SpiceDataHeader);
     channel->send_data.bufs[0].data = (void *)&channel->send_data.header;
 }
 
@@ -6181,99 +6181,99 @@ static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *disp
     RedChannel *channel = &display_channel->base;
     switch (drawable->type) {
     case QXL_DRAW_FILL:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_FILL;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_FILL;
         fill_base(display_channel, &display_channel->send_data.u.fill.base, item,
-                  sizeof(RedFill));
+                  sizeof(SpiceMsgDisplayDrawFill));
         display_channel->send_data.u.fill.data = drawable->u.fill;
         fill_brush(display_channel, &display_channel->send_data.u.fill.data.brush, item);
         fill_mask(display_channel, &display_channel->send_data.u.fill.data.mask, item);
         break;
     case QXL_DRAW_OPAQUE:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_OPAQUE;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_OPAQUE;
         fill_base(display_channel, &display_channel->send_data.u.opaque.base, item,
-                  sizeof(RedOpaque));
+                  sizeof(SpiceMsgDisplayDrawOpaque));
         display_channel->send_data.u.opaque.data = drawable->u.opaque;
         fill_bits(display_channel, &display_channel->send_data.u.opaque.data.src_bitmap, item);
         fill_brush(display_channel, &display_channel->send_data.u.opaque.data.brush, item);
         fill_mask(display_channel, &display_channel->send_data.u.opaque.data.mask, item);
         break;
     case QXL_DRAW_COPY:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_COPY;
-        fill_base(display_channel, &display_channel->send_data.u.copy.base, item, sizeof(RedCopy));
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_COPY;
+        fill_base(display_channel, &display_channel->send_data.u.copy.base, item, sizeof(SpiceMsgDisplayDrawCopy));
         display_channel->send_data.u.copy.data = drawable->u.copy;
         fill_bits(display_channel, &display_channel->send_data.u.copy.data.src_bitmap, item);
         fill_mask(display_channel, &display_channel->send_data.u.copy.data.mask, item);
         break;
     case QXL_DRAW_TRANSPARENT:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_TRANSPARENT;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_TRANSPARENT;
         fill_base(display_channel, &display_channel->send_data.u.transparent.base, item,
-                  sizeof(RedTransparent));
+                  sizeof(SpiceMsgDisplayDrawTransparent));
         display_channel->send_data.u.transparent.data = drawable->u.transparent;
         fill_bits(display_channel, &display_channel->send_data.u.transparent.data.src_bitmap, item);
         break;
     case QXL_DRAW_ALPHA_BLEND:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_ALPHA_BLEND;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND;
         fill_base(display_channel, &display_channel->send_data.u.alpha_blend.base, item,
-                  sizeof(RedAlphaBlend));
+                  sizeof(SpiceMsgDisplayDrawAlphaBlend));
         display_channel->send_data.u.alpha_blend.data = drawable->u.alpha_blend;
         fill_bits(display_channel, &display_channel->send_data.u.alpha_blend.data.src_bitmap, item);
         break;
     case QXL_COPY_BITS:
-        channel->send_data.header.type = RED_DISPLAY_COPY_BITS;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_COPY_BITS;
         fill_base(display_channel, &display_channel->send_data.u.copy_bits.base, item,
-                  sizeof(RedCopyBits));
+                  sizeof(SpiceMsgDisplayCopyBits));
         display_channel->send_data.u.copy_bits.src_pos = drawable->u.copy_bits.src_pos;
         break;
     case QXL_DRAW_BLEND:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_BLEND;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_BLEND;
         fill_base(display_channel, &display_channel->send_data.u.blend.base, item,
-                  sizeof(RedBlend));
+                  sizeof(SpiceMsgDisplayDrawBlend));
         display_channel->send_data.u.blend.data = drawable->u.blend;
         fill_bits(display_channel, &display_channel->send_data.u.blend.data.src_bitmap, item);
         fill_mask(display_channel, &display_channel->send_data.u.blend.data.mask, item);
         break;
     case QXL_DRAW_BLACKNESS:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_BLACKNESS;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_BLACKNESS;
         fill_base(display_channel, &display_channel->send_data.u.blackness.base, item,
-                  sizeof(RedBlackness));
+                  sizeof(SpiceMsgDisplayDrawBlackness));
         display_channel->send_data.u.blackness.data = drawable->u.blackness;
         fill_mask(display_channel, &display_channel->send_data.u.blackness.data.mask, item);
         break;
     case QXL_DRAW_WHITENESS:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_WHITENESS;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_WHITENESS;
         fill_base(display_channel, &display_channel->send_data.u.whiteness.base, item,
-                  sizeof(RedWhiteness));
+                  sizeof(SpiceMsgDisplayDrawWhiteness));
         display_channel->send_data.u.whiteness.data = drawable->u.whiteness;
         fill_mask(display_channel, &display_channel->send_data.u.whiteness.data.mask, item);
         break;
     case QXL_DRAW_INVERS:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_INVERS;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_INVERS;
         fill_base(display_channel, &display_channel->send_data.u.invers.base, item,
-                  sizeof(RedInvers));
+                  sizeof(SpiceMsgDisplayDrawInvers));
         display_channel->send_data.u.invers.data = drawable->u.invers;
         fill_mask(display_channel, &display_channel->send_data.u.invers.data.mask, item);
         break;
     case QXL_DRAW_ROP3:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_ROP3;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_ROP3;
         fill_base(display_channel, &display_channel->send_data.u.rop3.base, item,
-                  sizeof(RedRop3));
+                  sizeof(SpiceMsgDisplayDrawRop3));
         display_channel->send_data.u.rop3.data = drawable->u.rop3;
         fill_bits(display_channel, &display_channel->send_data.u.rop3.data.src_bitmap, item);
         fill_brush(display_channel, &display_channel->send_data.u.rop3.data.brush, item);
         fill_mask(display_channel, &display_channel->send_data.u.rop3.data.mask, item);
         break;
     case QXL_DRAW_STROKE:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_STROKE;
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_STROKE;
         fill_base(display_channel, &display_channel->send_data.u.stroke.base, item,
-                  sizeof(RedStroke));
+                  sizeof(SpiceMsgDisplayDrawStroke));
         display_channel->send_data.u.stroke.data = drawable->u.stroke;
         fill_path(display_channel, &display_channel->send_data.u.stroke.data.path, item->group_id);
         fill_attr(display_channel, &display_channel->send_data.u.stroke.data.attr, item->group_id);
         fill_brush(display_channel, &display_channel->send_data.u.stroke.data.brush, item);
         break;
     case QXL_DRAW_TEXT:
-        channel->send_data.header.type = RED_DISPLAY_DRAW_TEXT;
-        fill_base(display_channel, &display_channel->send_data.u.text.base, item, sizeof(RedText));
+        channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_TEXT;
+        fill_base(display_channel, &display_channel->send_data.u.text.base, item, sizeof(SpiceMsgDisplayDrawText));
         display_channel->send_data.u.text.data = drawable->u.text;
         fill_brush(display_channel, &display_channel->send_data.u.text.data.fore_brush, item);
         fill_brush(display_channel, &display_channel->send_data.u.text.data.back_brush, item);
@@ -6443,14 +6443,14 @@ static void display_channel_push_release(DisplayChannel *channel, uint8_t type,
     }
 
     if (free_list->res->count == free_list->res_size) {
-        RedResorceList *new_list;
-        new_list = malloc(sizeof(*new_list) + free_list->res_size * sizeof(RedResorceID) * 2);
+        SpiceResorceList *new_list;
+        new_list = malloc(sizeof(*new_list) + free_list->res_size * sizeof(SpiceResorceID) * 2);
         if (!new_list) {
             PANIC("malloc failed");
         }
         new_list->count = free_list->res->count;
         memcpy(new_list->resorces, free_list->res->resorces,
-               new_list->count * sizeof(RedResorceID));
+               new_list->count * sizeof(SpiceResorceID));
         free(free_list->res);
         free_list->res = new_list;
         free_list->res_size *= 2;
@@ -6461,7 +6461,7 @@ static void display_channel_push_release(DisplayChannel *channel, uint8_t type,
 
 static inline void red_begin_send_massage(RedChannel *channel, void *item)
 {
-    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->send_data.size = channel->send_data.header.size + sizeof(SpiceDataHeader);
     channel->messages_window++;
     red_send_data(channel, item);
 }
@@ -6478,19 +6478,19 @@ static inline void display_begin_send_massage(DisplayChannel *channel, void *ite
         channel->base.send_data.header.sub_list = channel->base.send_data.header.size;
         for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
             if (i != channel->base.id && free_list->sync[i] != 0) {
-                free_list->wait.header.wait_list[sync_count].channel_type = RED_CHANNEL_DISPLAY;
+                free_list->wait.header.wait_list[sync_count].channel_type = SPICE_CHANNEL_DISPLAY;
                 free_list->wait.header.wait_list[sync_count].channel_id = i;
                 free_list->wait.header.wait_list[sync_count++].message_serial = free_list->sync[i];
             }
         }
-        RedSubMessageList *sub_list = &channel->send_data.sub_list.sub_list;
-        RedSubMessage *sub_header = channel->send_data.sub_header;
+        SpiceSubMessageList *sub_list = &channel->send_data.sub_list.sub_list;
+        SpicedSubMessage *sub_header = channel->send_data.sub_header;
         if (sync_count) {
             sub_list->size = 2;
             add_buf((RedChannel*)channel, BUF_TYPE_RAW, sub_list,
                     sizeof(*sub_list) + 2 * sizeof(sub_list->sub_messages[0]), 0, 0);
             sub_list->sub_messages[0] = channel->base.send_data.header.size;
-            sub_header[0].type = RED_WAIT_FOR_CHANNELS;
+            sub_header[0].type = SPICE_MSG_WAIT_FOR_CHANNELS;
             sub_header[0].size = sizeof(free_list->wait.header) +
                                  sync_count * sizeof(free_list->wait.buf[0]);
             add_buf((RedChannel*)channel, BUF_TYPE_RAW, sub_header, sizeof(*sub_header), 0, 0);
@@ -6506,7 +6506,7 @@ static inline void display_begin_send_massage(DisplayChannel *channel, void *ite
             sub_list->sub_messages[0] = channel->base.send_data.header.size;
             sub_index = 0;
         }
-        sub_header[sub_index].type = RED_DISPLAY_INVAL_LIST;
+        sub_header[sub_index].type = SPICE_MSG_DISPLAY_INVAL_LIST;
         sub_header[sub_index].size = sizeof(*free_list->res) + free_list->res->count *
                                      sizeof(free_list->res->resorces[0]);
         add_buf((RedChannel*)channel, BUF_TYPE_RAW, &sub_header[sub_index], sizeof(*sub_header), 0,
@@ -6600,7 +6600,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
     qxl_image = (QXLImage *)get_virt(worker,  drawable->qxl_drawable->u.copy.src_bitmap,
                                      sizeof(QXLImage), drawable->group_id);
 
-    if (qxl_image->descriptor.type != IMAGE_TYPE_BITMAP ||
+    if (qxl_image->descriptor.type != SPICE_IMAGE_TYPE_BITMAP ||
                                             (qxl_image->bitmap.flags & QXL_BITMAP_DIRECT)) {
         return FALSE;
     }
@@ -6615,7 +6615,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
     data = qxl_image->bitmap.data;
 
     switch (qxl_image->bitmap.format) {
-    case BITMAP_FMT_32BIT:
+    case SPICE_BITMAP_FMT_32BIT:
         if (!red_rgb_to_yuv420_32bpp(worker, &drawable->qxl_drawable->u.copy.src_area,
                                      &qxl_image->bitmap, stream->av_frame,
                                      get_virt_delta(worker, data, drawable->group_id),
@@ -6624,7 +6624,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
             return FALSE;
         }
         break;
-    case BITMAP_FMT_16BIT:
+    case SPICE_BITMAP_FMT_16BIT:
         if (!red_rgb_to_yuv420_16bpp(worker, &drawable->qxl_drawable->u.copy.src_area,
                                      &qxl_image->bitmap, stream->av_frame,
                                      get_virt_delta(worker, data, drawable->group_id),
@@ -6633,7 +6633,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
             return FALSE;
         }
         break;
-    case BITMAP_FMT_24BIT:
+    case SPICE_BITMAP_FMT_24BIT:
         if (!red_rgb_to_yuv420_24bpp(worker, &drawable->qxl_drawable->u.copy.src_area,
                                      &qxl_image->bitmap, stream->av_frame,
                                      get_virt_delta(worker, data, drawable->group_id),
@@ -6709,9 +6709,9 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
         break;
     }
  #endif
-    channel->send_data.header.type = RED_DISPLAY_STREAM_DATA;
-    RedStreamData* stream_data = &display_channel->send_data.u.stream_data;
-    add_buf(channel, BUF_TYPE_RAW, stream_data, sizeof(RedStreamData), 0, 0);
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_STREAM_DATA;
+    SpiceMsgDisplayStreamData* stream_data = &display_channel->send_data.u.stream_data;
+    add_buf(channel, BUF_TYPE_RAW, stream_data, sizeof(SpiceMsgDisplayStreamData), 0, 0);
     add_buf(channel, BUF_TYPE_RAW, display_channel->send_data.stream_outbuf,
             n + FF_INPUT_BUFFER_PADDING_SIZE, 0, 0);
 
@@ -6750,12 +6750,12 @@ static void red_send_mode(DisplayChannel *display_channel)
     }
 
     channel = &display_channel->base;
-    channel->send_data.header.type = RED_DISPLAY_MODE;
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_MODE;
     display_channel->send_data.u.mode.x_res = worker->surface.context.width;
     display_channel->send_data.u.mode.y_res = worker->surface.context.height;
     display_channel->send_data.u.mode.bits = worker->surface.context.depth;
 
-    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.mode, sizeof(RedMode), 0, 0);
+    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.mode, sizeof(SpiceMsgDisplayMode), 0, 0);
 
     display_begin_send_massage(display_channel, NULL);
 }
@@ -6763,12 +6763,12 @@ static void red_send_mode(DisplayChannel *display_channel)
 static void red_send_set_ack(RedChannel *channel)
 {
     ASSERT(channel);
-    channel->send_data.header.type = RED_SET_ACK;
+    channel->send_data.header.type = SPICE_MSG_SET_ACK;
     channel->send_data.u.ack.generation = ++channel->ack_generation;
     channel->send_data.u.ack.window = channel->client_ack_window;
     channel->messages_window = 0;
 
-    add_buf(channel, BUF_TYPE_RAW, &channel->send_data.u.ack, sizeof(RedSetAck), 0, 0);
+    add_buf(channel, BUF_TYPE_RAW, &channel->send_data.u.ack, sizeof(SpiceMsgSetAck), 0, 0);
     red_begin_send_massage(channel, NULL);
 }
 
@@ -6787,14 +6787,14 @@ static inline void display_send_verb(DisplayChannel *channel, uint16_t verb)
 }
 
 static inline void __red_send_inval(RedChannel *channel, CacheItem *cach_item,
-                                    RedInvalOne *inval_one)
+                                    SpiceMsgDisplayInvalOne *inval_one)
 {
     channel->send_data.header.type = cach_item->inval_type;
     inval_one->id = *(uint64_t *)&cach_item->id;
     add_buf(channel, BUF_TYPE_RAW, inval_one, sizeof(*inval_one), 0, 0);
 }
 
-static void red_send_inval(RedChannel *channel, CacheItem *cach_item, RedInvalOne *inval_one)
+static void red_send_inval(RedChannel *channel, CacheItem *cach_item, SpiceMsgDisplayInvalOne *inval_one)
 {
     __red_send_inval(channel, cach_item, inval_one);
     red_begin_send_massage(channel, NULL);
@@ -6809,9 +6809,9 @@ static void red_display_send_inval(DisplayChannel *display_channel, CacheItem *c
 
 static void display_channel_send_migrate(DisplayChannel *display_channel)
 {
-    display_channel->base.send_data.header.type = RED_MIGRATE;
-    display_channel->send_data.u.migrate.flags = RED_MIGRATE_NEED_FLUSH |
-                                                 RED_MIGRATE_NEED_DATA_TRANSFER;
+    display_channel->base.send_data.header.type = SPICE_MSG_MIGRATE;
+    display_channel->send_data.u.migrate.flags = SPICE_MIGRATE_NEED_FLUSH |
+                                                 SPICE_MIGRATE_NEED_DATA_TRANSFER;
     add_buf((RedChannel*)display_channel, BUF_TYPE_RAW, &display_channel->send_data.u.migrate,
             sizeof(display_channel->send_data.u.migrate), 0, 0);
     display_channel->expect_migrate_mark = TRUE;
@@ -6822,7 +6822,7 @@ static void display_channel_send_migrate_data(DisplayChannel *display_channel)
 {
     DisplayChannelMigrateData* display_data;
 
-    display_channel->base.send_data.header.type = RED_MIGRATE_DATA;
+    display_channel->base.send_data.header.type = SPICE_MSG_MIGRATE_DATA;
     ASSERT(display_channel->pixmap_cache);
     display_data = &display_channel->send_data.u.migrate_data;
     display_data->magic = DISPLAY_MIGRATE_DATA_MAGIC;
@@ -6851,11 +6851,11 @@ static void display_channel_send_migrate_data(DisplayChannel *display_channel)
 
 static void display_channel_pixmap_sync(DisplayChannel *display_channel)
 {
-    RedWaitForChannels *wait;
+    SpiceMsgWaitForChannels *wait;
     PixmapCache *pixmap_cache;
 
 
-    display_channel->base.send_data.header.type = RED_WAIT_FOR_CHANNELS;
+    display_channel->base.send_data.header.type = SPICE_MSG_WAIT_FOR_CHANNELS;
     wait = &display_channel->send_data.u.wait.header;
     pixmap_cache = display_channel->pixmap_cache;
 
@@ -6863,7 +6863,7 @@ static void display_channel_pixmap_sync(DisplayChannel *display_channel)
     pthread_mutex_lock(&pixmap_cache->lock);
 
     wait->wait_count = 1;
-    wait->wait_list[0].channel_type = RED_CHANNEL_DISPLAY;
+    wait->wait_list[0].channel_type = SPICE_CHANNEL_DISPLAY;
     wait->wait_list[0].channel_id = pixmap_cache->generation_initiator.client;
     wait->wait_list[0].message_serial = pixmap_cache->generation_initiator.message;
     display_channel->pixmap_cache_generation = pixmap_cache->generation;
@@ -6878,9 +6878,9 @@ static void display_channel_pixmap_sync(DisplayChannel *display_channel)
 
 static void display_channel_reset_cache(DisplayChannel *display_channel)
 {
-    RedWaitForChannels *wait = &display_channel->send_data.u.wait.header;
+    SpiceMsgWaitForChannels *wait = &display_channel->send_data.u.wait.header;
 
-    display_channel->base.send_data.header.type = RED_DISPLAY_INVAL_ALL_PIXMAPS;
+    display_channel->base.send_data.header.type = SPICE_MSG_DISPLAY_INVAL_ALL_PIXMAPS;
     pixmap_cache_reset(display_channel->pixmap_cache, display_channel, wait);
 
     add_buf((RedChannel *)display_channel, BUF_TYPE_RAW, wait,
@@ -6893,7 +6893,7 @@ static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
     RedChannel *channel;
     RedImage *red_image;
     RedWorker *worker;
-    Bitmap bitmap;
+    SpiceBitmap bitmap;
 
     ASSERT(display_channel && item);
     channel = &display_channel->base;
@@ -6903,30 +6903,30 @@ static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
     ASSERT(red_image);
 
     QXL_SET_IMAGE_ID(red_image, QXL_IMAGE_GROUP_RED, ++worker->bits_unique);
-    red_image->descriptor.type = IMAGE_TYPE_BITMAP;
+    red_image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
     red_image->descriptor.flags = 0;
     red_image->descriptor.width = item->width;
     red_image->descriptor.height = item->height;
 
-    bitmap.format = BITMAP_FMT_32BIT;
+    bitmap.format = SPICE_BITMAP_FMT_32BIT;
     bitmap.flags = QXL_BITMAP_DIRECT;
     bitmap.flags |= item->top_down ? QXL_BITMAP_TOP_DOWN : 0;
     bitmap.x = item->width;
     bitmap.y = item->height;
     bitmap.stride = item->stride;
     bitmap.palette = 0;
-    bitmap.data = (ADDRESS)item->data;
+    bitmap.data = (SPICE_ADDRESS)item->data;
 
-    channel->send_data.header.type = RED_DISPLAY_DRAW_COPY;
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_COPY;
 
-    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.copy, sizeof(RedCopy), 0, 0);
+    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.copy, sizeof(SpiceMsgDisplayDrawCopy), 0, 0);
     display_channel->send_data.u.copy.base.box.left = item->pos.x;
     display_channel->send_data.u.copy.base.box.top = item->pos.y;
     display_channel->send_data.u.copy.base.box.right = item->pos.x + bitmap.x;
     display_channel->send_data.u.copy.base.box.bottom = item->pos.y + bitmap.y;
-    display_channel->send_data.u.copy.base.clip.type = CLIP_TYPE_NONE;
+    display_channel->send_data.u.copy.base.clip.type = SPICE_CLIP_TYPE_NONE;
     display_channel->send_data.u.copy.base.clip.data = 0;
-    display_channel->send_data.u.copy.data.rop_decriptor = ROPD_OP_PUT;
+    display_channel->send_data.u.copy.data.rop_decriptor = SPICE_ROPD_OP_PUT;
     display_channel->send_data.u.copy.data.src_area.left = 0;
     display_channel->send_data.u.copy.data.src_area.top = 0;
     display_channel->send_data.u.copy.data.src_area.right = bitmap.x;
@@ -6943,10 +6943,10 @@ static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
         add_buf(channel, BUF_TYPE_COMPRESS_BUF, comp_send_data.comp_buf,
                 comp_send_data.comp_buf_size, 0, 0);
     } else {
-        red_image->descriptor.type = IMAGE_TYPE_BITMAP;
+        red_image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
         red_image->bitmap = bitmap;
         red_image->bitmap.flags &= ~QXL_BITMAP_DIRECT;
-        add_buf(channel, BUF_TYPE_RAW, red_image, sizeof(BitmapImage), 0, 0);
+        add_buf(channel, BUF_TYPE_RAW, red_image, sizeof(SpiceBitmapImage), 0, 0);
         red_image->bitmap.data = channel->send_data.header.size;
         add_buf(channel, BUF_TYPE_RAW, item->data, bitmap.y * bitmap.stride, 0, 0);
     }
@@ -6957,24 +6957,24 @@ static void red_display_send_upgrade(DisplayChannel *display_channel, UpgradeIte
 {
     RedChannel *channel;
     QXLDrawable *qxl_drawable;
-    RedCopy *copy = &display_channel->send_data.u.copy;
+    SpiceMsgDisplayDrawCopy *copy = &display_channel->send_data.u.copy;
 
     ASSERT(display_channel && item && item->drawable);
     channel = &display_channel->base;
 
-    channel->send_data.header.type = RED_DISPLAY_DRAW_COPY;
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_DRAW_COPY;
 
     qxl_drawable = item->drawable->qxl_drawable;
     ASSERT(qxl_drawable->type == QXL_DRAW_COPY);
-    ASSERT(qxl_drawable->u.copy.rop_decriptor == ROPD_OP_PUT);
+    ASSERT(qxl_drawable->u.copy.rop_decriptor == SPICE_ROPD_OP_PUT);
     ASSERT(qxl_drawable->u.copy.mask.bitmap == 0);
 
-    add_buf(channel, BUF_TYPE_RAW, copy, sizeof(RedCopy), 0, 0);
+    add_buf(channel, BUF_TYPE_RAW, copy, sizeof(SpiceMsgDisplayDrawCopy), 0, 0);
     copy->base.box = qxl_drawable->bbox;
-    copy->base.clip.type = CLIP_TYPE_RECTS;
+    copy->base.clip.type = SPICE_CLIP_TYPE_RECTS;
     copy->base.clip.data = channel->send_data.header.size;
     add_buf(channel, BUF_TYPE_RAW, &item->region.num_rects, sizeof(uint32_t), 0, 0);
-    add_buf(channel, BUF_TYPE_RAW, item->region.rects, sizeof(Rect) * item->region.num_rects, 0, 0);
+    add_buf(channel, BUF_TYPE_RAW, item->region.rects, sizeof(SpiceRect) * item->region.num_rects, 0, 0);
     copy->data = qxl_drawable->u.copy;
     fill_bits(display_channel, &copy->data.src_bitmap, item->drawable);
 
@@ -6988,11 +6988,11 @@ static void red_display_send_stream_start(DisplayChannel *display_channel, Strea
 
     agent->lats_send_time = 0;
     ASSERT(stream);
-    channel->send_data.header.type = RED_DISPLAY_STREAM_CREATE;
-    RedStreamCreate *stream_create = &display_channel->send_data.u.stream_create.message;
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_STREAM_CREATE;
+    SpiceMsgDisplayStreamCreate *stream_create = &display_channel->send_data.u.stream_create.message;
     stream_create->id = agent - display_channel->stream_agents;
-    stream_create->flags = stream->top_down ? STREAM_TOP_DOWN : 0;
-    stream_create->codec_type = RED_VIDEO_CODEC_TYPE_MJPEG;
+    stream_create->flags = stream->top_down ? SPICE_STREAM_FLAGS_TOP_DOWN : 0;
+    stream_create->codec_type = SPICE_VIDEO_CODEC_TYPE_MJPEG;
 
     stream_create->src_width = stream->width;
     stream_create->src_height = stream->height;
@@ -7004,14 +7004,14 @@ static void red_display_send_stream_start(DisplayChannel *display_channel, Strea
     if (stream->current) {
         QXLDrawable *qxl_drawable = stream->current->qxl_drawable;
         stream_create->clip = qxl_drawable->clip;
-        if (qxl_drawable->clip.type == CLIP_TYPE_RECTS) {
+        if (qxl_drawable->clip.type == SPICE_CLIP_TYPE_RECTS) {
             fill_rects_clip(channel, &stream_create->clip.data, stream->current->group_id);
         } else {
-            ASSERT(qxl_drawable->clip.type == CLIP_TYPE_NONE);
+            ASSERT(qxl_drawable->clip.type == SPICE_CLIP_TYPE_NONE);
         }
         display_begin_send_massage(display_channel, &stream->current->pipe_item);
     } else {
-        stream_create->clip.type = CLIP_TYPE_RECTS;
+        stream_create->clip.type = SPICE_CLIP_TYPE_RECTS;
         stream_create->clip.data = channel->send_data.header.size;
         display_channel->send_data.u.stream_create.num_rects = 0;
         add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.stream_create.num_rects,
@@ -7030,18 +7030,18 @@ static void red_display_send_stream_clip(DisplayChannel *display_channel,
 
     ASSERT(stream);
 
-    channel->send_data.header.type = RED_DISPLAY_STREAM_CLIP;
-    RedStreamClip *stream_clip = &display_channel->send_data.u.stream_clip;
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_STREAM_CLIP;
+    SpiceMsgDisplayStreamClip *stream_clip = &display_channel->send_data.u.stream_clip;
     add_buf(channel, BUF_TYPE_RAW, stream_clip, sizeof(*stream_clip), 0, 0);
     stream_clip->id = agent - display_channel->stream_agents;
-    if ((stream_clip->clip.type = item->clip_type) == CLIP_TYPE_NONE) {
+    if ((stream_clip->clip.type = item->clip_type) == SPICE_CLIP_TYPE_NONE) {
         stream_clip->clip.data = 0;
     } else {
-        ASSERT(stream_clip->clip.type == CLIP_TYPE_RECTS);
+        ASSERT(stream_clip->clip.type == SPICE_CLIP_TYPE_RECTS);
         stream_clip->clip.data = channel->send_data.header.size;
         add_buf(channel, BUF_TYPE_RAW, &item->region.num_rects, sizeof(uint32_t), 0, 0);
         add_buf(channel, BUF_TYPE_RAW, item->region.rects,
-                item->region.num_rects * sizeof(Rect), 0, 0);
+                item->region.num_rects * sizeof(SpiceRect), 0, 0);
     }
     display_begin_send_massage(display_channel, item);
 }
@@ -7049,10 +7049,10 @@ static void red_display_send_stream_clip(DisplayChannel *display_channel,
 static void red_display_send_stream_end(DisplayChannel *display_channel, StreamAgent* agent)
 {
     RedChannel *channel = &display_channel->base;
-    channel->send_data.header.type = RED_DISPLAY_STREAM_DESTROY;
+    channel->send_data.header.type = SPICE_MSG_DISPLAY_STREAM_DESTROY;
     display_channel->send_data.u.stream_destroy.id = agent - display_channel->stream_agents;
     add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.stream_destroy,
-            sizeof(RedStreamDestroy), 0, 0);
+            sizeof(SpiceMsgDisplayStreamDestroy), 0, 0);
     display_begin_send_massage(display_channel, NULL);
 }
 
@@ -7069,12 +7069,12 @@ static void red_send_cursor_init(CursorChannel *channel)
 
     worker = channel->base.worker;
 
-    channel->base.send_data.header.type = RED_CURSOR_INIT;
+    channel->base.send_data.header.type = SPICE_MSG_CURSOR_INIT;
     channel->send_data.u.cursor_init.visible = worker->cursor_visible;
     channel->send_data.u.cursor_init.position = worker->cursor_position;
     channel->send_data.u.cursor_init.trail_length = worker->cursor_trail_length;
     channel->send_data.u.cursor_init.trail_frequency = worker->cursor_trail_frequency;
-    add_buf(&channel->base, BUF_TYPE_RAW, &channel->send_data.u.cursor_init, sizeof(RedCursorInit),
+    add_buf(&channel->base, BUF_TYPE_RAW, &channel->send_data.u.cursor_init, sizeof(SpiceMsgCursorInit),
             0, 0);
 
     fill_cursor(channel, &channel->send_data.u.cursor_init.cursor, worker->cursor);
@@ -7089,11 +7089,11 @@ static void red_send_local_cursor(CursorChannel *cursor_channel, LocalCursor *cu
     ASSERT(cursor_channel);
 
     channel = &cursor_channel->base;
-    channel->send_data.header.type = RED_CURSOR_SET;
+    channel->send_data.header.type = SPICE_MSG_CURSOR_SET;
     cursor_channel->send_data.u.cursor_set.postition = cursor->position;
     cursor_channel->send_data.u.cursor_set.visible = channel->worker->cursor_visible;
     add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_set,
-            sizeof(RedCursorSet), 0, 0);
+            sizeof(SpiceMsgCursorSet), 0, 0);
     fill_cursor(cursor_channel, &cursor_channel->send_data.u.cursor_set.cursor, &cursor->base);
 
     red_begin_send_massage(channel, cursor);
@@ -7103,7 +7103,7 @@ static void red_send_local_cursor(CursorChannel *cursor_channel, LocalCursor *cu
 
 static void cursor_channel_send_migrate(CursorChannel *cursor_channel)
 {
-    cursor_channel->base.send_data.header.type = RED_MIGRATE;
+    cursor_channel->base.send_data.header.type = SPICE_MSG_MIGRATE;
     cursor_channel->send_data.u.migrate.flags = 0;
     add_buf((RedChannel*)cursor_channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.migrate,
             sizeof(cursor_channel->send_data.u.migrate), 0, 0);
@@ -7122,28 +7122,28 @@ static void red_send_cursor(CursorChannel *cursor_channel, CursorItem *cursor)
     cmd = cursor->qxl_cursor;
     switch (cmd->type) {
     case QXL_CURSOR_MOVE:
-        channel->send_data.header.type = RED_CURSOR_MOVE;
+        channel->send_data.header.type = SPICE_MSG_CURSOR_MOVE;
         cursor_channel->send_data.u.cursor_move.postition = cmd->u.position;
         add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_move,
-                sizeof(RedCursorMove), 0, 0);
+                sizeof(SpiceMsgCursorMove), 0, 0);
         break;
     case QXL_CURSOR_SET:
-        channel->send_data.header.type = RED_CURSOR_SET;
+        channel->send_data.header.type = SPICE_MSG_CURSOR_SET;
         cursor_channel->send_data.u.cursor_set.postition = cmd->u.set.position;
         cursor_channel->send_data.u.cursor_set.visible = channel->worker->cursor_visible;
         add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_set,
-                sizeof(RedCursorSet), 0, 0);
+                sizeof(SpiceMsgCursorSet), 0, 0);
         fill_cursor(cursor_channel, &cursor_channel->send_data.u.cursor_set.cursor, cursor);
         break;
     case QXL_CURSOR_HIDE:
-        channel->send_data.header.type = RED_CURSOR_HIDE;
+        channel->send_data.header.type = SPICE_MSG_CURSOR_HIDE;
         break;
     case QXL_CURSOR_TRAIL:
-        channel->send_data.header.type = RED_CURSOR_TRAIL;
+        channel->send_data.header.type = SPICE_MSG_CURSOR_TRAIL;
         cursor_channel->send_data.u.cursor_trail.length = cmd->u.trail.length;
         cursor_channel->send_data.u.cursor_trail.frequency = cmd->u.trail.frequency;
         add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_trail,
-                sizeof(RedCursorTrail), 0, 0);
+                sizeof(SpiceMsgCursorTrail), 0, 0);
         break;
     default:
         red_error("bad cursor command %d", cmd->type);
@@ -7248,7 +7248,7 @@ static void display_channel_push(RedWorker *worker)
             break;
         case PIPE_ITEM_TYPE_INVAL_PALLET_CACHE:
             red_reset_palette_cache(display_channel);
-            red_send_verb((RedChannel *)display_channel, RED_DISPLAY_INVAL_ALL_PALETTES);
+            red_send_verb((RedChannel *)display_channel, SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES);
             free(pipe_item);
             break;
         default:
@@ -7297,7 +7297,7 @@ static void cursor_channel_push(RedWorker *worker)
             break;
         case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
             red_reset_cursor_cache(cursor_channel);
-            red_send_verb((RedChannel *)cursor_channel, RED_CURSOR_INVAL_ALL);
+            red_send_verb((RedChannel *)cursor_channel, SPICE_MSG_CURSOR_INVAL_ALL);
             free(pipe_item);
             break;
         default:
@@ -7424,7 +7424,7 @@ static void red_disconnect_display(RedChannel *channel)
 static void red_migrate_display(RedWorker *worker)
 {
     if (worker->display_channel) {
-        red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_STREAM_DESTROY_ALL);
+        red_pipe_add_verb(&worker->display_channel->base, SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL);
         red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_MIGRATE);
     }
 }
@@ -7442,7 +7442,7 @@ static void destroy_cairo_canvas(CairoCanvas *canvas)
     cairo_destroy(cairo);
 }
 
-static void validate_area_nop(void *canvas, int32_t stride, uint8_t *line_0, const Rect *area)
+static void validate_area_nop(void *canvas, int32_t stride, uint8_t *line_0, const SpiceRect *area)
 {
 }
 
@@ -7507,7 +7507,7 @@ static void destroy_gl_canvas(GLCanvas *canvas)
     oglctx_destroy(ctx);
 }
 
-static void gl_validate_area(GLCanvas *canvas, int32_t stride, uint8_t *line_0, const Rect *area)
+static void gl_validate_area(GLCanvas *canvas, int32_t stride, uint8_t *line_0, const SpiceRect *area)
 {
     int h;
 
@@ -7791,28 +7791,28 @@ static void on_new_display_channel(RedWorker *worker)
         push_new_mode(worker);
         red_add_screen_image(worker);
         if (channel_is_connected(&display_channel->base)) {
-            red_pipe_add_verb(&display_channel->base, RED_DISPLAY_MARK);
+            red_pipe_add_verb(&display_channel->base, SPICE_MSG_DISPLAY_MARK);
             red_disply_start_streams(display_channel);
         }
     }
 }
 
-static int channel_handle_message(RedChannel *channel, RedDataHeader *message)
+static int channel_handle_message(RedChannel *channel, SpiceDataHeader *message)
 {
     switch (message->type) {
-    case REDC_ACK_SYNC:
+    case SPICE_MSGC_ACK_SYNC:
         if (message->size != sizeof(uint32_t)) {
             red_printf("bad message size");
             return FALSE;
         }
         channel->client_ack_generation = *(uint32_t *)(message + 1);
         break;
-    case REDC_ACK:
+    case SPICE_MSGC_ACK:
         if (channel->client_ack_generation == channel->ack_generation) {
             channel->messages_window -= channel->client_ack_window;
         }
         break;
-    case REDC_DISCONNECTING:
+    case SPICE_MSGC_DISCONNECTING:
         break;
     default:
         red_printf("invalid message type %u", message->type);
@@ -8017,14 +8017,14 @@ static void red_release_pixmap_cache(DisplayChannel *channel)
     free(cache);
 }
 
-static int display_channel_init_cache(DisplayChannel *channel, RedcDisplayInit *init_info)
+static int display_channel_init_cache(DisplayChannel *channel, SpiceMsgcDisplayInit *init_info)
 {
     ASSERT(!channel->pixmap_cache);
     return !!(channel->pixmap_cache = red_get_pixmap_cache(init_info->pixmap_cache_id,
                                                            init_info->pixmap_cache_size));
 }
 
-static int display_channel_init_glz_dictionary(DisplayChannel *channel, RedcDisplayInit *init_info)
+static int display_channel_init_glz_dictionary(DisplayChannel *channel, SpiceMsgcDisplayInit *init_info)
 {
     ASSERT(!channel->glz_dict);
     ring_init(&channel->glz_drawables);
@@ -8035,7 +8035,7 @@ static int display_channel_init_glz_dictionary(DisplayChannel *channel, RedcDisp
                                                          init_info->glz_dictionary_window_size));
 }
 
-static int display_channel_init(DisplayChannel *channel, RedcDisplayInit *init_info)
+static int display_channel_init(DisplayChannel *channel, SpiceMsgcDisplayInit *init_info)
 {
     return (display_channel_init_cache(channel, init_info) &&
             display_channel_init_glz_dictionary(channel, init_info));
@@ -8064,7 +8064,7 @@ static int display_channel_handle_migrate_mark(DisplayChannel *channel)
     return TRUE;
 }
 
-static int display_channel_handle_migrate_data(DisplayChannel *channel, RedDataHeader *message)
+static int display_channel_handle_migrate_data(DisplayChannel *channel, SpiceDataHeader *message)
 {
     DisplayChannelMigrateData *migrate_data;
     int i;
@@ -8115,23 +8115,23 @@ static int display_channel_handle_migrate_data(DisplayChannel *channel, RedDataH
     return TRUE;
 }
 
-static int display_channel_handle_message(RedChannel *channel, RedDataHeader *message)
+static int display_channel_handle_message(RedChannel *channel, SpiceDataHeader *message)
 {
     switch (message->type) {
-    case REDC_DISPLAY_INIT:
-        if (message->size != sizeof(RedcDisplayInit)) {
+    case SPICE_MSGC_DISPLAY_INIT:
+        if (message->size != sizeof(SpiceMsgcDisplayInit)) {
             red_printf("bad message size");
             return FALSE;
         }
         if (!((DisplayChannel *)channel)->expect_init) {
-            red_printf("unexpected REDC_DISPLAY_INIT");
+            red_printf("unexpected SPICE_MSGC_DISPLAY_INIT");
             return FALSE;
         }
         ((DisplayChannel *)channel)->expect_init = FALSE;
-        return display_channel_init((DisplayChannel *)channel, (RedcDisplayInit *)(message + 1));
-    case REDC_MIGRATE_FLUSH_MARK:
+        return display_channel_init((DisplayChannel *)channel, (SpiceMsgcDisplayInit *)(message + 1));
+    case SPICE_MSGC_MIGRATE_FLUSH_MARK:
         return display_channel_handle_migrate_mark((DisplayChannel *)channel);
-    case REDC_MIGRATE_DATA:
+    case SPICE_MSGC_MIGRATE_DATA:
         return display_channel_handle_migrate_data((DisplayChannel *)channel, message);
     default:
         return channel_handle_message(channel, message);
@@ -8167,28 +8167,28 @@ static void red_receive(RedChannel *channel)
         } else {
             channel->recive_data.now += n;
             for (;;) {
-                RedDataHeader *message = channel->recive_data.message;
+                SpiceDataHeader *message = channel->recive_data.message;
                 n = channel->recive_data.now - (uint8_t *)message;
-                if (n < sizeof(RedDataHeader) ||
-                    n < sizeof(RedDataHeader) + message->size) {
+                if (n < sizeof(SpiceDataHeader) ||
+                    n < sizeof(SpiceDataHeader) + message->size) {
                     break;
                 }
                 if (!channel->handle_message(channel, message)) {
                     channel->disconnect(channel);
                     return;
                 }
-                channel->recive_data.message = (RedDataHeader *)((uint8_t *)message +
-                                                                 sizeof(RedDataHeader) +
+                channel->recive_data.message = (SpiceDataHeader *)((uint8_t *)message +
+                                                                 sizeof(SpiceDataHeader) +
                                                                  message->size);
             }
 
             if (channel->recive_data.now == (uint8_t *)channel->recive_data.message) {
                 channel->recive_data.now = channel->recive_data.buf;
-                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+                channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf;
             } else if (channel->recive_data.now == channel->recive_data.end) {
                 memcpy(channel->recive_data.buf, channel->recive_data.message, n);
                 channel->recive_data.now = channel->recive_data.buf + n;
-                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+                channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf;
             }
         }
     }
@@ -8241,7 +8241,7 @@ static RedChannel *__new_channel(RedWorker *worker, int size, RedsStreamContext
     channel->client_ack_window = IS_LOW_BANDWIDTH() ? WIDE_CLIENT_ACK_WINDOW :
                                                       NARROW_CLIENT_ACK_WINDOW;
     channel->client_ack_generation = ~0;
-    channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+    channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf;
     channel->recive_data.now = channel->recive_data.buf;
     channel->recive_data.end = channel->recive_data.buf + sizeof(channel->recive_data.buf);
     ring_init(&channel->pipe);
@@ -8361,9 +8361,9 @@ static void handle_new_display_channel(RedWorker *worker, RedsStreamContext *pee
     worker->display_channel = display_channel;
 
 
-    if (!(display_channel->send_data.free_list.res = malloc(sizeof(RedResorceList) +
+    if (!(display_channel->send_data.free_list.res = malloc(sizeof(SpiceResorceList) +
                                                             DISPLAY_FREE_LIST_DEFAULT_SIZE *
-                                                            sizeof(RedResorceID)))) {
+                                                            sizeof(SpiceResorceID)))) {
         PANIC("free list alloc failed");
     }
     display_channel->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE;
@@ -8447,11 +8447,11 @@ static void red_connect_cursor(RedWorker *worker, RedsStreamContext *peer, int m
 
 typedef struct __attribute__ ((__packed__)) CursorData {
     uint32_t visible;
-    Point16 position;
+    SpicePoint16 position;
     uint16_t trail_length;
     uint16_t trail_frequency;
     uint32_t data_size;
-    RedCursor _cursor;
+    SpiceCursor _cursor;
 } CursorData;
 
 static void red_save_cursor(RedWorker *worker)
@@ -8464,7 +8464,7 @@ static void red_save_cursor(RedWorker *worker)
     ASSERT(worker->cursor->type == CURSOR_TYPE_LOCAL);
 
     local = (LocalCursor *)worker->cursor;
-    size = sizeof(CursorData) + sizeof(RedCursor) + local->data_size;
+    size = sizeof(CursorData) + sizeof(SpiceCursor) + local->data_size;
     cursor_data = malloc(size);
     ASSERT(cursor_data);
 
@@ -8478,7 +8478,7 @@ static void red_save_cursor(RedWorker *worker)
     worker->qxl->set_save_data(worker->qxl, cursor_data, size);
 }
 
-static LocalCursor *_new_local_cursor(CursorHeader *header, int data_size, Point16 position)
+static LocalCursor *_new_local_cursor(SpiceCursorHeader *header, int data_size, SpicePoint16 position)
 {
     LocalCursor *local;
 
@@ -8686,16 +8686,16 @@ static inline void handle_dev_destroy_surfaces(RedWorker *worker)
     if (worker->cursor_channel) {
         red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
         if (!worker->cursor_channel->base.migrate) {
-            red_pipe_add_verb(&worker->cursor_channel->base, RED_CURSOR_RESET);
+            red_pipe_add_verb(&worker->cursor_channel->base, SPICE_MSG_CURSOR_RESET);
         }
         ASSERT(!worker->cursor_channel->base.send_data.item);
     }
 
     if (worker->display_channel) {
         red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_INVAL_PALLET_CACHE);
-        red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_STREAM_DESTROY_ALL);
+        red_pipe_add_verb(&worker->display_channel->base, SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL);
         if (!worker->display_channel->base.migrate) {
-            red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_RESET);
+            red_pipe_add_verb(&worker->display_channel->base, SPICE_MSG_DISPLAY_RESET);
         }
     }
 
@@ -8735,7 +8735,7 @@ static inline void handle_dev_create_primary_surface(RedWorker *worker)
 
     if (worker->display_channel) {
         red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_MODE);
-        red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_MARK);
+        red_pipe_add_verb(&worker->display_channel->base, SPICE_MSG_DISPLAY_MARK);
         display_channel_push(worker);
     }
 
@@ -8765,7 +8765,7 @@ static inline void handle_dev_destroy_primary_surface(RedWorker *worker)
     if (worker->cursor_channel) {
         red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
         if (!worker->cursor_channel->base.migrate) {
-            red_pipe_add_verb(&worker->cursor_channel->base, RED_CURSOR_RESET);
+            red_pipe_add_verb(&worker->cursor_channel->base, SPICE_MSG_CURSOR_RESET);
         }
         ASSERT(!worker->cursor_channel->base.send_data.item);
     }
@@ -8844,7 +8844,7 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
         if (worker->cursor_channel) {
             red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
             if (!worker->cursor_channel->base.migrate) {
-                red_pipe_add_verb(&worker->cursor_channel->base, RED_CURSOR_RESET);
+                red_pipe_add_verb(&worker->cursor_channel->base, SPICE_MSG_CURSOR_RESET);
             }
             ASSERT(!worker->cursor_channel->base.send_data.item);
 
@@ -9040,7 +9040,7 @@ static void red_init(RedWorker *worker, WorkerInitData *init_data)
     worker->num_renderers = init_data->num_renderers;
     memcpy(worker->renderers, init_data->renderers, sizeof(worker->renderers));
     worker->renderer = RED_RENDERER_INVALID;
-    worker->mouse_mode = RED_MOUSE_MODE_SERVER;
+    worker->mouse_mode = SPICE_MOUSE_MODE_SERVER;
     worker->image_compression = init_data->image_compression;
     worker->streaming_video = init_data->streaming_video;
     ring_init(&worker->current_list);
@@ -9089,7 +9089,7 @@ void *red_worker_main(void *arg)
     red_printf("begin");
     ASSERT(MAX_PIPE_SIZE > WIDE_CLIENT_ACK_WINDOW &&
            MAX_PIPE_SIZE > NARROW_CLIENT_ACK_WINDOW); //ensure wakeup by ack message
-    ASSERT(QXL_BITMAP_TOP_DOWN == BITMAP_TOP_DOWN);
+    ASSERT(QXL_BITMAP_TOP_DOWN == SPICE_BITMAP_FLAGS_TOP_DOWN);
 
 #if  defined(RED_WORKER_STAT) || defined(COMPRESS_STAT)
     if (pthread_getcpuclockid(pthread_self(), &clock_id)) {
@@ -9157,7 +9157,7 @@ void *red_worker_main(void *arg)
 
 #ifdef DUMP_BITMAP
 #include <stdio.h>
-static void dump_palette(FILE *f, Palette* plt)
+static void dump_palette(FILE *f, SpicePalette* plt)
 {
     int i;
     for (i = 0; i < plt->num_ents; i++) {
@@ -9181,14 +9181,14 @@ static void dump_line(FILE *f, uint8_t* line, uint16_t n_pixel_bits, int width,
 
 #define RAM_PATH "/tmp/tmpfs"
 
-static void dump_bitmap(RedWorker *worker, Bitmap *bitmap, uint32_t group_id)
+static void dump_bitmap(RedWorker *worker, SpiceBitmap *bitmap, uint32_t group_id)
 {
     static uint32_t file_id = 0;
 
     char file_str[200];
     int rgb = TRUE;
     uint16_t n_pixel_bits;
-    Palette *plt = NULL;
+    SpicePalette *plt = NULL;
     uint32_t id;
     int row_size;
     uint32_t file_size;
@@ -9201,30 +9201,30 @@ static void dump_bitmap(RedWorker *worker, Bitmap *bitmap, uint32_t group_id)
     FILE *f;
 
     switch (bitmap->format) {
-    case BITMAP_FMT_1BIT_BE:
-    case BITMAP_FMT_1BIT_LE:
+    case SPICE_BITMAP_FMT_1BIT_BE:
+    case SPICE_BITMAP_FMT_1BIT_LE:
         rgb = FALSE;
         n_pixel_bits = 1;
         break;
-    case BITMAP_FMT_4BIT_BE:
-    case BITMAP_FMT_4BIT_LE:
+    case SPICE_BITMAP_FMT_4BIT_BE:
+    case SPICE_BITMAP_FMT_4BIT_LE:
         rgb = FALSE;
         n_pixel_bits = 4;
         break;
-    case BITMAP_FMT_8BIT:
+    case SPICE_BITMAP_FMT_8BIT:
         rgb = FALSE;
         n_pixel_bits = 8;
         break;
-    case BITMAP_FMT_16BIT:
+    case SPICE_BITMAP_FMT_16BIT:
         n_pixel_bits = 16;
         break;
-    case BITMAP_FMT_24BIT:
+    case SPICE_BITMAP_FMT_24BIT:
         n_pixel_bits = 24;
         break;
-    case BITMAP_FMT_32BIT:
+    case SPICE_BITMAP_FMT_32BIT:
         n_pixel_bits = 32;
         break;
-    case BITMAP_FMT_RGBA:
+    case SPICE_BITMAP_FMT_RGBA:
         n_pixel_bits = 32;
         alpha = 1;
         break;
@@ -9236,7 +9236,7 @@ static void dump_bitmap(RedWorker *worker, Bitmap *bitmap, uint32_t group_id)
         if (!bitmap->palette) {
             return; // dont dump masks.
         }
-        plt = (Palette *)get_virt(worker, bitmap->palette, sizeof(Palette), group_id);
+        plt = (SpicePalette *)get_virt(worker, bitmap->palette, sizeof(SpicePalette), group_id);
     }
     row_size = (((bitmap->x * n_pixel_bits) + 31) / 32) * 4;
     bitmap_data_offset = header_size;
@@ -9301,7 +9301,7 @@ static void dump_bitmap(RedWorker *worker, Bitmap *bitmap, uint32_t group_id)
     } else {
         QXLDataChunk *chunk = NULL;
         int num_lines;
-        ADDRESS relative_address = bitmap->data;
+        SPICE_ADDRESS relative_address = bitmap->data;
 
         while (relative_address) {
             int i;
diff --git a/server/red_yuv.h b/server/red_yuv.h
index 85597475..756717d5 100644
--- a/server/red_yuv.h
+++ b/server/red_yuv.h
@@ -83,8 +83,8 @@ static inline void FUNC_NAME(red_rgb_to_yuv420_line)(const uint8_t* line0, const
     }
 }
 
-static inline int FUNC_NAME(red_rgb_to_yuv420)(RedWorker *worker, const Rect *src,
-                                               const Bitmap *image, AVFrame *frame,
+static inline int FUNC_NAME(red_rgb_to_yuv420)(RedWorker *worker, const SpiceRect *src,
+                                               const SpiceBitmap *image, AVFrame *frame,
                                                long phys_delta, int memslot_id, int id,
                                                Stream *stream, uint32_t group_id)
 {
diff --git a/server/reds.c b/server/reds.c
index fb26901a..bb71ae74 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -97,7 +97,7 @@ static void openssl_init();
 
 // approximate max recive message size
 #define RECIVE_BUF_SIZE \
-    (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * RED_AGENT_MAX_DATA_SIZE)
+    (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * SPICE_AGENT_MAX_DATA_SIZE)
 
 #define SEND_BUF_SIZE 4096
 
@@ -110,7 +110,7 @@ typedef struct IncomingHandler {
     int shut;
     uint8_t buf[RECIVE_BUF_SIZE];
     uint32_t end_pos;
-    void (*handle_message)(void *opaque, RedDataHeader *message);
+    void (*handle_message)(void *opaque, SpiceDataHeader *message);
 } IncomingHandler;
 
 typedef struct OutgoingHandler {
@@ -123,7 +123,7 @@ typedef struct OutgoingHandler {
 } OutgoingHandler;
 
 typedef struct TicketAuthentication {
-    char password[RED_MAX_PASSWORD_LENGTH];
+    char password[SPICE_MAX_PASSWORD_LENGTH];
     time_t expiration_time;
 } TicketAuthentication;
 
@@ -133,7 +133,7 @@ typedef struct TicketInfo {
     RSA *rsa;
     int rsa_size;
     BIGNUM *bn;
-    RedLinkEncryptedTicket encrypted_ticket;
+    SpiceLinkEncryptedTicket encrypted_ticket;
 } TicketInfo;
 
 typedef struct MonitorMode {
@@ -151,8 +151,8 @@ struct RedsOutItem {
 typedef struct VDIReadBuf {
     RedsOutItem out_item;
     int len;
-    RedDataHeader header;
-    uint8_t data[RED_AGENT_MAX_DATA_SIZE];
+    SpiceDataHeader header;
+    uint8_t data[SPICE_AGENT_MAX_DATA_SIZE];
 } VDIReadBuf;
 
 enum {
@@ -226,7 +226,7 @@ enum NetTestStage {
 #ifdef RED_STATISTICS
 
 #define REDS_MAX_STAT_NODES 100
-#define REDS_STAT_SHM_SIZE (sizeof(RedsStat) + REDS_MAX_STAT_NODES * sizeof(StatNode))
+#define REDS_STAT_SHM_SIZE (sizeof(SpiceStat) + REDS_MAX_STAT_NODES * sizeof(SpiceStatNode))
 
 typedef struct RedsStatValue {
     uint32_t value;
@@ -270,7 +270,7 @@ typedef struct RedsState {
 
 #ifdef RED_STATISTICS
     char *stat_shm_name;
-    RedsStat *stat;
+    SpiceStat *stat;
     pthread_mutex_t stat_lock;
     RedsStatValue roundtrip_stat;
     VDObjectRef ping_timer;
@@ -300,8 +300,8 @@ typedef struct AsyncRead {
 typedef struct RedLinkInfo {
     RedsStreamContext *peer;
     AsyncRead asyc_read;
-    RedLinkHeader link_header;
-    RedLinkMess *link_mess;
+    SpiceLinkHeader link_header;
+    SpiceLinkMess *link_mess;
     int mess_pos;
     TicketInfo tiTicketing;
 } RedLinkInfo;
@@ -317,7 +317,7 @@ struct  __attribute__ ((__packed__)) VDIPortBuf {
 
 typedef struct __attribute__ ((__packed__)) VDAgentExtBuf {
     VDIPortBuf base;
-    uint8_t buf[RED_AGENT_MAX_DATA_SIZE];
+    uint8_t buf[SPICE_AGENT_MAX_DATA_SIZE];
     VDIChunkHeader migrate_overflow;
 } VDAgentExtBuf;
 
@@ -352,8 +352,8 @@ struct ChannelSecurityOptions {
 
 typedef struct PingItem {
     RedsOutItem base;
-    RedDataHeader header;
-    RedPing ping;
+    SpiceDataHeader header;
+    SpiceMsgPing ping;
     int size;
 } PingItem;
 
@@ -617,11 +617,11 @@ static struct iovec *reds_iovec_skip(struct iovec vec[], int skip, int *vec_size
 
 static void print_stat_tree(uint32_t node_index, int depth)
 {
-    StatNode *node = &reds->stat->nodes[node_index];
+    SpiceStatNode *node = &reds->stat->nodes[node_index];
 
-    if ((node->flags & STAT_NODE_MASK_SHOW) == STAT_NODE_MASK_SHOW) {
+    if ((node->flags & SPICE_STAT_NODE_MASK_SHOW) == SPICE_STAT_NODE_MASK_SHOW) {
         core->term_printf(core, "%*s%s", depth * STAT_TAB_LEN, "", node->name);
-        if (node->flags & STAT_NODE_FLAG_VALUE) {
+        if (node->flags & SPICE_STAT_NODE_FLAG_VALUE) {
             core->term_printf(core, ":%*s%llu\n",
                               (STAT_VALUE_TABS - depth) * STAT_TAB_LEN - strlen(node->name) - 1, "",
                               node->value);
@@ -645,12 +645,12 @@ static void do_info_statistics()
 
 static void do_reset_statistics()
 {
-    StatNode *node;
+    SpiceStatNode *node;
     int i;
 
     for (i = 0; i <= REDS_MAX_STAT_NODES; i++) {
         node = &reds->stat->nodes[i];
-        if (node->flags & STAT_NODE_FLAG_VALUE) {
+        if (node->flags & SPICE_STAT_NODE_FLAG_VALUE) {
             node->value = 0;
         }
     }
@@ -668,11 +668,11 @@ static void do_reset_statistics_2(const VDICmdArg* args)
 
 void insert_stat_node(StatNodeRef parent, StatNodeRef ref)
 {
-    StatNode *node = &reds->stat->nodes[ref];
+    SpiceStatNode *node = &reds->stat->nodes[ref];
     uint32_t pos = INVALID_STAT_REF;
     uint32_t node_index;
     uint32_t *head;
-    StatNode *n;
+    SpiceStatNode *n;
 
     node->first_child_index = INVALID_STAT_REF;
     head = (parent == INVALID_STAT_REF ? &reds->stat->root_index :
@@ -696,7 +696,7 @@ void insert_stat_node(StatNodeRef parent, StatNodeRef ref)
 StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible)
 {
     StatNodeRef ref;
-    StatNode *node;
+    SpiceStatNode *node;
 
     ASSERT(name && strlen(name) > 0);
     if (strlen(name) >= sizeof(node->name)) {
@@ -722,23 +722,23 @@ StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible)
     reds->stat->num_of_nodes++;
     for (ref = 0; ref <= REDS_MAX_STAT_NODES; ref++) {
         node = &reds->stat->nodes[ref];
-        if (!(node->flags & STAT_NODE_FLAG_ENABLED)) {
+        if (!(node->flags & SPICE_STAT_NODE_FLAG_ENABLED)) {
             break;
         }
     }
-    ASSERT(!(node->flags & STAT_NODE_FLAG_ENABLED));
+    ASSERT(!(node->flags & SPICE_STAT_NODE_FLAG_ENABLED));
     node->value = 0;
-    node->flags = STAT_NODE_FLAG_ENABLED | (visible ? STAT_NODE_FLAG_VISIBLE : 0);
+    node->flags = SPICE_STAT_NODE_FLAG_ENABLED | (visible ? SPICE_STAT_NODE_FLAG_VISIBLE : 0);
     strncpy(node->name, name, sizeof(node->name));
     insert_stat_node(parent, ref);
     pthread_mutex_unlock(&reds->stat_lock);
     return ref;
 }
 
-void stat_remove(StatNode *node)
+void stat_remove(SpiceStatNode *node)
 {
     pthread_mutex_lock(&reds->stat_lock);
-    node->flags &= ~STAT_NODE_FLAG_ENABLED;
+    node->flags &= ~SPICE_STAT_NODE_FLAG_ENABLED;
     reds->stat->generation++;
     reds->stat->num_of_nodes--;
     pthread_mutex_unlock(&reds->stat_lock);
@@ -752,19 +752,19 @@ void stat_remove_node(StatNodeRef ref)
 uint64_t *stat_add_counter(StatNodeRef parent, const char *name, int visible)
 {
     StatNodeRef ref = stat_add_node(parent, name, visible);
-    StatNode *node;
+    SpiceStatNode *node;
 
     if (ref == INVALID_STAT_REF) {
         return NULL;
     }
     node = &reds->stat->nodes[ref];
-    node->flags |= STAT_NODE_FLAG_VALUE;
+    node->flags |= SPICE_STAT_NODE_FLAG_VALUE;
     return &node->value;
 }
 
 void stat_remove_counter(uint64_t *counter)
 {
-    stat_remove((StatNode *)(counter - offsetof(StatNode, value)));
+    stat_remove((SpiceStatNode *)(counter - offsetof(SpiceStatNode, value)));
 }
 
 static void reds_update_stat_value(RedsStatValue* stat_value, uint32_t value)
@@ -926,7 +926,7 @@ static int handle_incoming(RedsStreamContext *peer, IncomingHandler *handler)
         uint8_t *buf = handler->buf;
         uint32_t pos = handler->end_pos;
         uint8_t *end = buf + pos;
-        RedDataHeader *header;
+        SpiceDataHeader *header;
         int n;
         n = peer->cb_read(peer->ctx, buf + pos, RECIVE_BUF_SIZE - pos);
         if (n <= 0) {
@@ -947,9 +947,9 @@ static int handle_incoming(RedsStreamContext *peer, IncomingHandler *handler)
         } else {
             pos += n;
             end = buf + pos;
-            while (buf + sizeof(RedDataHeader) <= end &&
-                   buf + sizeof(RedDataHeader) + (header = (RedDataHeader *)buf)->size <= end) {
-                buf += sizeof(RedDataHeader) + header->size;
+            while (buf + sizeof(SpiceDataHeader) <= end &&
+                   buf + sizeof(SpiceDataHeader) + (header = (SpiceDataHeader *)buf)->size <= end) {
+                buf += sizeof(SpiceDataHeader) + header->size;
                 handler->handle_message(handler->opaque, header);
 
                 if (handler->shut) {
@@ -1036,7 +1036,7 @@ static int outgoing_write(RedsStreamContext *peer, OutgoingHandler *handler, voi
 
 typedef struct SimpleOutItem {
     RedsOutItem base;
-    RedDataHeader header;
+    SpiceDataHeader header;
     uint8_t data[0];
 } SimpleOutItem;
 
@@ -1087,19 +1087,19 @@ static void reds_push_pipe_item(RedsOutItem *item)
 
 static void reds_send_channels()
 {
-    RedChannels* channels_info;
+    SpiceMsgChannels* channels_info;
     SimpleOutItem *item;
     int message_size;
     Channel *channel;
     int i;
 
-    message_size = sizeof(RedChannels) + reds->num_of_channels * sizeof(RedChannelInit);
-    if (!(item = new_simple_out_item(RED_CHANNELS_LIST, message_size))) {
+    message_size = sizeof(SpiceMsgChannels) + reds->num_of_channels * sizeof(SpiceChannelId);
+    if (!(item = new_simple_out_item(SPICE_MSG_MAIN_CHANNELS_LIST, message_size))) {
         red_printf("alloc item failed");
         reds_disconnect();
         return;
     }
-    channels_info = (RedChannels *)item->data;
+    channels_info = (SpiceMsgChannels *)item->data;
     channels_info->num_of_channels = reds->num_of_channels;
     channel = reds->channels;
 
@@ -1151,7 +1151,7 @@ static int send_ping(int size)
     item->base.release = reds_free_ping_item;
 
     item->header.serial = ++reds->serial;
-    item->header.type = RED_PING;
+    item->header.type = SPICE_MSG_PING;
     item->header.size = sizeof(item->ping) + size;
     item->header.sub_list = 0;
 
@@ -1237,22 +1237,22 @@ static void do_info_rtt_client()
 
 static void reds_send_mouse_mode()
 {
-    RedMouseMode *mouse_mode;
+    SpiceMsgMainMouseMode *mouse_mode;
     SimpleOutItem *item;
 
     if (!reds->peer) {
         return;
     }
 
-    if (!(item = new_simple_out_item(RED_MOUSE_MODE, sizeof(RedMouseMode)))) {
+    if (!(item = new_simple_out_item(SPICE_MSG_MAIN_MOUSE_MODE, sizeof(SpiceMsgMainMouseMode)))) {
         red_printf("alloc item failed");
         reds_disconnect();
         return;
     }
-    mouse_mode = (RedMouseMode *)item->data;
-    mouse_mode->supported_modes = RED_MOUSE_MODE_SERVER;
+    mouse_mode = (SpiceMsgMainMouseMode *)item->data;
+    mouse_mode->supported_modes = SPICE_MOUSE_MODE_SERVER;
     if (reds->is_client_mouse_allowed) {
-        mouse_mode->supported_modes |= RED_MOUSE_MODE_CLIENT;
+        mouse_mode->supported_modes |= SPICE_MOUSE_MODE_CLIENT;
     }
     mouse_mode->current_mode = reds->mouse_mode;
     reds_push_pipe_item(&item->base);
@@ -1280,8 +1280,8 @@ static void reds_update_mouse_mode()
         return;
     }
     reds->is_client_mouse_allowed = allowed;
-    if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT && !allowed) {
-        reds_set_mouse_mode(RED_MOUSE_MODE_SERVER);
+    if (reds->mouse_mode == SPICE_MOUSE_MODE_CLIENT && !allowed) {
+        reds_set_mouse_mode(SPICE_MOUSE_MODE_SERVER);
         return;
     }
     reds_send_mouse_mode();
@@ -1290,7 +1290,7 @@ static void reds_update_mouse_mode()
 static void reds_send_agent_connected()
 {
     SimpleOutItem *item;
-    if (!(item = new_simple_out_item(RED_AGENT_CONNECTED, 0))) {
+    if (!(item = new_simple_out_item(SPICE_MSG_MAIN_AGENT_CONNECTED, 0))) {
         PANIC("alloc item failed");
     }
     reds_push_pipe_item(&item->base);
@@ -1298,14 +1298,14 @@ static void reds_send_agent_connected()
 
 static void reds_send_agent_disconnected()
 {
-    RedAgentDisconnect *disconnect;
+    SpiceMsgMainAgentDisconnect *disconnect;
     SimpleOutItem *item;
 
-    if (!(item = new_simple_out_item(RED_AGENT_DISCONNECTED, sizeof(RedAgentDisconnect)))) {
+    if (!(item = new_simple_out_item(SPICE_MSG_MAIN_AGENT_DISCONNECTED, sizeof(SpiceMsgMainAgentDisconnect)))) {
         PANIC("alloc item failed");
     }
-    disconnect = (RedAgentDisconnect *)item->data;
-    disconnect->error_code = RED_ERR_OK;
+    disconnect = (SpiceMsgMainAgentDisconnect *)item->data;
+    disconnect->error_code = SPICE_LINK_ERR_OK;
     reds_push_pipe_item(&item->base);
 }
 
@@ -1334,19 +1334,19 @@ static void reds_agent_remove()
 
 static void reds_send_tokens()
 {
-    RedAgentTokens *tokens;
+    SpiceMsgMainAgentTokens *tokens;
     SimpleOutItem *item;
 
     if (!reds->peer) {
         return;
     }
 
-    if (!(item = new_simple_out_item(RED_AGENT_TOKEN, sizeof(RedAgentTokens)))) {
+    if (!(item = new_simple_out_item(SPICE_MSG_MAIN_AGENT_TOKEN, sizeof(SpiceMsgMainAgentTokens)))) {
         red_printf("alloc item failed");
         reds_disconnect();
         return;
     }
-    tokens = (RedAgentTokens *)item->data;
+    tokens = (SpiceMsgMainAgentTokens *)item->data;
     tokens->num_tokens = reds->agent_state.num_tokens;
     reds->agent_state.num_client_tokens += tokens->num_tokens;
     ASSERT(reds->agent_state.num_client_tokens <= REDS_AGENT_WINDOW_SIZE);
@@ -1545,7 +1545,7 @@ typedef struct WriteQueueInfo {
 
 typedef struct SendMainMigrateItem {
     RedsOutItem base;
-    RedDataHeader header;
+    SpiceDataHeader header;
     MainMigrateData data;
     WriteQueueInfo queue_info[REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES];
 } SendMainMigrateItem;
@@ -1562,7 +1562,7 @@ static void main_channel_send_migrate_data_item(RedsOutItem *in_item, struct iov
     vec = vec_start;
 
     item->header.serial = ++reds->serial;
-    item->header.type = RED_MIGRATE_DATA;
+    item->header.type = SPICE_MSG_MIGRATE_DATA;
     item->header.size = sizeof(item->data);
     item->header.sub_list = 0;
 
@@ -1713,7 +1713,7 @@ static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **
         buff = state->current_read_buf = (VDIReadBuf *)ring_item;
         buff->len = data->read_buf_len;
         n = buff->len - state->recive_len;
-        if (buff->len > RED_AGENT_MAX_DATA_SIZE || n > RED_AGENT_MAX_DATA_SIZE) {
+        if (buff->len > SPICE_AGENT_MAX_DATA_SIZE || n > SPICE_AGENT_MAX_DATA_SIZE) {
             red_printf("bad read position");
             reds_disconnect();
             return FALSE;
@@ -1863,23 +1863,23 @@ static void main_channel_recive_migrate_data(MainMigrateData *data, uint8_t *end
     ASSERT(state->num_client_tokens + state->num_tokens == REDS_AGENT_WINDOW_SIZE);
 }
 
-static void reds_main_handle_message(void *opaque, RedDataHeader *message)
+static void reds_main_handle_message(void *opaque, SpiceDataHeader *message)
 {
     switch (message->type) {
-    case REDC_AGENT_START: {
-        RedcAgentTokens *agent_start;
+    case SPICE_MSGC_MAIN_AGENT_START: {
+        SpiceMsgcMainAgentTokens *agent_start;
 
         red_printf("agent start");
         if (!reds->peer) {
             return;
         }
-        agent_start = (RedcAgentTokens *)(message + 1);
+        agent_start = (SpiceMsgcMainAgentTokens *)(message + 1);
         reds->agent_state.client_agent_started = TRUE;
         reds->agent_state.send_tokens = agent_start->num_tokens;
         read_from_vdi_port();
         break;
     }
-    case REDC_AGENT_DATA: {
+    case SPICE_MSGC_MAIN_AGENT_DATA: {
         RingItem *ring_item;
         VDAgentExtBuf *buf;
 
@@ -1896,12 +1896,12 @@ static void reds_main_handle_message(void *opaque, RedDataHeader *message)
         }
 
         if (!reds->agent_state.client_agent_started) {
-            red_printf("REDC_AGENT_DATA race");
+            red_printf("SPICE_MSGC_MAIN_AGENT_DATA race");
             add_token();
             break;
         }
 
-        if (message->size > RED_AGENT_MAX_DATA_SIZE) {
+        if (message->size > SPICE_AGENT_MAX_DATA_SIZE) {
             red_printf("invalid agent message");
             reds_disconnect();
             break;
@@ -1922,53 +1922,53 @@ static void reds_main_handle_message(void *opaque, RedDataHeader *message)
         write_to_vdi_port();
         break;
     }
-    case REDC_AGENT_TOKEN: {
-        RedcAgentTokens *token;
+    case SPICE_MSGC_MAIN_AGENT_TOKEN: {
+        SpiceMsgcMainAgentTokens *token;
 
         if (!reds->agent_state.client_agent_started) {
-            red_printf("REDC_AGENT_TOKEN race");
+            red_printf("SPICE_MSGC_MAIN_AGENT_TOKEN race");
             break;
         }
 
-        token = (RedcAgentTokens *)(message + 1);
+        token = (SpiceMsgcMainAgentTokens *)(message + 1);
         reds->agent_state.send_tokens += token->num_tokens;
         read_from_vdi_port();
         break;
     }
-    case REDC_ATTACH_CHANNELS:
+    case SPICE_MSGC_MAIN_ATTACH_CHANNELS:
         reds_send_channels();
         break;
-    case REDC_MIGRATE_CONNECTED:
+    case SPICE_MSGC_MAIN_MIGRATE_CONNECTED:
         red_printf("connected");
         if (reds->mig_wait_connect) {
             reds_mig_cleanup();
         }
         break;
-    case REDC_MIGRATE_CONNECT_ERROR:
+    case SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR:
         red_printf("mig connect error");
         if (reds->mig_wait_connect) {
             reds_mig_cleanup();
         }
         break;
-    case REDC_MOUSE_MODE_REQUEST: {
-        switch (((RedcMouseModeRequest *)(message + 1))->mode) {
-        case RED_MOUSE_MODE_CLIENT:
+    case SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST: {
+        switch (((SpiceMsgcMainMouseModeRequest *)(message + 1))->mode) {
+        case SPICE_MOUSE_MODE_CLIENT:
             if (reds->is_client_mouse_allowed) {
-                reds_set_mouse_mode(RED_MOUSE_MODE_CLIENT);
+                reds_set_mouse_mode(SPICE_MOUSE_MODE_CLIENT);
             } else {
                 red_printf("client mouse is disabled");
             }
             break;
-        case RED_MOUSE_MODE_SERVER:
-            reds_set_mouse_mode(RED_MOUSE_MODE_SERVER);
+        case SPICE_MOUSE_MODE_SERVER:
+            reds_set_mouse_mode(SPICE_MOUSE_MODE_SERVER);
             break;
         default:
             red_printf("unsupported mouse mode");
         }
         break;
     }
-    case REDC_PONG: {
-        RedPing *ping = (RedPing *)(message + 1);
+    case SPICE_MSGC_PONG: {
+        SpiceMsgPing *ping = (SpiceMsgPing *)(message + 1);
         uint64_t roundtrip;
         struct timespec ts;
 
@@ -2017,16 +2017,16 @@ static void reds_main_handle_message(void *opaque, RedDataHeader *message)
 #endif
         break;
     }
-    case REDC_MIGRATE_FLUSH_MARK:
+    case SPICE_MSGC_MIGRATE_FLUSH_MARK:
         main_channel_push_migrate_data_item();
         break;
-    case REDC_MIGRATE_DATA:
+    case SPICE_MSGC_MIGRATE_DATA:
         main_channel_recive_migrate_data((MainMigrateData *)(message + 1),
                                          (uint8_t *)(message + 1) + message->size);
         reds->mig_target = FALSE;
         while (write_to_vdi_port() || read_from_vdi_port());
         break;
-    case REDC_DISCONNECTING:
+    case SPICE_MSGC_DISCONNECTING:
         break;
     default:
         red_printf("unexpected type %d", message->type);
@@ -2126,19 +2126,19 @@ static int sync_write(RedsStreamContext *peer, void *in_buf, size_t n)
 
 static int reds_send_link_ack(RedLinkInfo *link)
 {
-    RedLinkHeader header;
-    RedLinkReply ack;
+    SpiceLinkHeader header;
+    SpiceLinkReply ack;
     Channel *channel;
     BUF_MEM *bmBuf;
     BIO *bio;
     int ret;
 
-    header.magic = RED_MAGIC;
+    header.magic = SPICE_MAGIC;
     header.size = sizeof(ack);
-    header.major_version = RED_VERSION_MAJOR;
-    header.minor_version = RED_VERSION_MINOR;
+    header.major_version = SPICE_VERSION_MAJOR;
+    header.minor_version = SPICE_VERSION_MINOR;
 
-    ack.error = RED_ERR_OK;
+    ack.error = SPICE_LINK_ERR_OK;
 
     if ((channel = reds_find_channel(link->link_mess->channel_type, 0))) {
         ack.num_common_caps = channel->num_common_caps;
@@ -2148,7 +2148,7 @@ static int reds_send_link_ack(RedLinkInfo *link)
         ack.num_common_caps = 0;
         ack.num_channel_caps = 0;
     }
-    ack.caps_offset = sizeof(RedLinkReply);
+    ack.caps_offset = sizeof(SpiceLinkReply);
 
     if (!(link->tiTicketing.rsa = RSA_new())) {
         red_printf("RSA nes failed");
@@ -2160,7 +2160,7 @@ static int reds_send_link_ack(RedLinkInfo *link)
         return FALSE;
     }
 
-    RSA_generate_key_ex(link->tiTicketing.rsa, RED_TICKET_KEY_PAIR_LENGTH, link->tiTicketing.bn,
+    RSA_generate_key_ex(link->tiTicketing.rsa, SPICE_TICKET_KEY_PAIR_LENGTH, link->tiTicketing.bn,
                         NULL);
     link->tiTicketing.rsa_size = RSA_size(link->tiTicketing.rsa);
 
@@ -2181,13 +2181,13 @@ static int reds_send_link_ack(RedLinkInfo *link)
 
 static int reds_send_link_error(RedLinkInfo *link, uint32_t error)
 {
-    RedLinkHeader header;
-    RedLinkReply reply;
+    SpiceLinkHeader header;
+    SpiceLinkReply reply;
 
-    header.magic = RED_MAGIC;
+    header.magic = SPICE_MAGIC;
     header.size = sizeof(reply);
-    header.major_version = RED_VERSION_MAJOR;
-    header.minor_version = RED_VERSION_MINOR;
+    header.major_version = SPICE_VERSION_MAJOR;
+    header.minor_version = SPICE_VERSION_MINOR;
     memset(&reply, 0, sizeof(reply));
     reply.error = error;
     return sync_write(link->peer, &header, sizeof(header)) && sync_write(link->peer, &reply,
@@ -2228,7 +2228,7 @@ static void reds_handle_main_link(RedLinkInfo *link)
     reds_disconnect();
 
     if (!link->link_mess->connection_id) {
-        reds_send_link_result(link, RED_ERR_OK);
+        reds_send_link_result(link, SPICE_LINK_ERR_OK);
         while((connection_id = rand()) == 0);
         reds->agent_state.num_tokens = 0;
         reds->agent_state.send_tokens = 0;
@@ -2236,11 +2236,11 @@ static void reds_handle_main_link(RedLinkInfo *link)
         reds->mig_target = FALSE;
     } else {
         if (link->link_mess->connection_id != reds->link_id) {
-            reds_send_link_result(link, RED_ERR_BAD_CONNECTION_ID);
+            reds_send_link_result(link, SPICE_LINK_ERR_BAD_CONNECTION_ID);
             reds_release_link(link);
             return;
         }
-        reds_send_link_result(link, RED_ERR_OK);
+        reds_send_link_result(link, SPICE_LINK_ERR_OK);
         connection_id = link->link_mess->connection_id;
         reds->mig_target = TRUE;
     }
@@ -2270,20 +2270,20 @@ static void reds_handle_main_link(RedLinkInfo *link)
 
     if (!reds->mig_target) {
         SimpleOutItem *item;
-        RedInit *init;
+        SpiceMsgMainInit *init;
 
-        if (!(item = new_simple_out_item(RED_INIT, sizeof(RedInit)))) {
+        if (!(item = new_simple_out_item(SPICE_MSG_MAIN_INIT, sizeof(SpiceMsgMainInit)))) {
             red_printf("alloc item failed");
             reds_disconnect();
             return;
         }
-        init = (RedInit *)item->data;
+        init = (SpiceMsgMainInit *)item->data;
         init->session_id = connection_id;
         init->display_channels_hint = red_dispatcher_count();
         init->current_mouse_mode = reds->mouse_mode;
-        init->supported_mouse_modes = RED_MOUSE_MODE_SERVER;
+        init->supported_mouse_modes = SPICE_MOUSE_MODE_SERVER;
         if (reds->is_client_mouse_allowed) {
-            init->supported_mouse_modes |= RED_MOUSE_MODE_CLIENT;
+            init->supported_mouse_modes |= SPICE_MOUSE_MODE_CLIENT;
         }
         init->agent_connected = !!vdagent;
         init->agent_tokens = REDS_AGENT_WINDOW_SIZE;
@@ -2296,14 +2296,14 @@ static void reds_handle_main_link(RedLinkInfo *link)
 }
 
 #define RED_MOUSE_STATE_TO_LOCAL(state)     \
-    ((state & REDC_LBUTTON_MASK) |          \
-     ((state & REDC_MBUTTON_MASK) << 1) |   \
-     ((state & REDC_RBUTTON_MASK) >> 1))
+    ((state & SPICE_MOUSE_BUTTON_MASK_LEFT) |          \
+     ((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) << 1) |   \
+     ((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) >> 1))
 
 #define RED_MOUSE_BUTTON_STATE_TO_AGENT(state)                      \
-    (((state & REDC_LBUTTON_MASK) ? VD_AGENT_LBUTTON_MASK : 0) |    \
-     ((state & REDC_MBUTTON_MASK) ? VD_AGENT_MBUTTON_MASK : 0) |    \
-     ((state & REDC_RBUTTON_MASK) ? VD_AGENT_RBUTTON_MASK : 0))
+    (((state & SPICE_MOUSE_BUTTON_MASK_LEFT) ? VD_AGENT_LBUTTON_MASK : 0) |    \
+     ((state & SPICE_MOUSE_BUTTON_MASK_MIDDLE) ? VD_AGENT_MBUTTON_MASK : 0) |    \
+     ((state & SPICE_MOUSE_BUTTON_MASK_RIGHT) ? VD_AGENT_RBUTTON_MASK : 0))
 
 static void activate_modifiers_watch()
 {
@@ -2318,21 +2318,21 @@ static void push_key_scan(uint8_t scan)
     keyboard->push_scan_freg(keyboard, scan);
 }
 
-static void inputs_handle_input(void *opaque, RedDataHeader *header)
+static void inputs_handle_input(void *opaque, SpiceDataHeader *header)
 {
     InputsState *state = (InputsState *)opaque;
     uint8_t *buf = (uint8_t *)(header + 1);
 
     switch (header->type) {
-    case REDC_INPUTS_KEY_DOWN: {
-        RedcKeyDown *key_up = (RedcKeyDown *)buf;
+    case SPICE_MSGC_INPUTS_KEY_DOWN: {
+        SpiceMsgcKeyDown *key_up = (SpiceMsgcKeyDown *)buf;
         if (key_up->code == CAPS_LOCK_SCAN_CODE || key_up->code == NUM_LOCK_SCAN_CODE ||
             key_up->code == SCROLL_LOCK_SCAN_CODE) {
             activate_modifiers_watch();
         }
     }
-    case REDC_INPUTS_KEY_UP: {
-        RedcKeyDown *key_down = (RedcKeyDown *)buf;
+    case SPICE_MSGC_INPUTS_KEY_UP: {
+        SpiceMsgcKeyDown *key_down = (SpiceMsgcKeyDown *)buf;
         uint8_t *now = (uint8_t *)&key_down->code;
         uint8_t *end = now + sizeof(key_down->code);
         for (; now < end && *now; now++) {
@@ -2340,45 +2340,45 @@ static void inputs_handle_input(void *opaque, RedDataHeader *header)
         }
         break;
     }
-    case REDC_INPUTS_MOUSE_MOTION: {
-        RedcMouseMotion *mouse_motion = (RedcMouseMotion *)buf;
+    case SPICE_MSGC_INPUTS_MOUSE_MOTION: {
+        SpiceMsgcMouseMotion *mouse_motion = (SpiceMsgcMouseMotion *)buf;
 
-        if (++state->motion_count % RED_MOTION_ACK_BUNCH == 0) {
-            RedDataHeader header;
+        if (++state->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0) {
+            SpiceDataHeader header;
 
             header.serial = ++state->serial;
-            header.type = RED_INPUTS_MOUSE_MOTION_ACK;
+            header.type = SPICE_MSG_INPUTS_MOUSE_MOTION_ACK;
             header.size = 0;
             header.sub_list = 0;
-            if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+            if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(SpiceDataHeader))
                                                                                 != OUTGOING_OK) {
                 red_printf("motion ack failed");
                 reds_disconnect();
             }
         }
-        if (mouse && reds->mouse_mode == RED_MOUSE_MODE_SERVER) {
+        if (mouse && reds->mouse_mode == SPICE_MOUSE_MODE_SERVER) {
             mouse->moution(mouse, mouse_motion->dx, mouse_motion->dy, 0,
                            RED_MOUSE_STATE_TO_LOCAL(mouse_motion->buttons_state));
         }
         break;
     }
-    case REDC_INPUTS_MOUSE_POSITION: {
-        RedcMousePosition *pos = (RedcMousePosition *)buf;
+    case SPICE_MSGC_INPUTS_MOUSE_POSITION: {
+        SpiceMsgcMousePosition *pos = (SpiceMsgcMousePosition *)buf;
 
-        if (++state->motion_count % RED_MOTION_ACK_BUNCH == 0) {
-            RedDataHeader header;
+        if (++state->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0) {
+            SpiceDataHeader header;
 
             header.serial = ++state->serial;
-            header.type = RED_INPUTS_MOUSE_MOTION_ACK;
+            header.type = SPICE_MSG_INPUTS_MOUSE_MOTION_ACK;
             header.size = 0;
             header.sub_list = 0;
-            if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+            if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(SpiceDataHeader))
                                                                                 != OUTGOING_OK) {
                 red_printf("position ack failed");
                 reds_disconnect();
             }
         }
-        if (reds->mouse_mode != RED_MOUSE_MODE_CLIENT) {
+        if (reds->mouse_mode != SPICE_MOUSE_MODE_CLIENT) {
             break;
         }
         ASSERT((agent_mouse && vdagent) || tablet);
@@ -2394,15 +2394,15 @@ static void inputs_handle_input(void *opaque, RedDataHeader *header)
         reds_handle_agent_mouse_event();
         break;
     }
-    case REDC_INPUTS_MOUSE_PRESS: {
-        RedcMousePress *mouse_press = (RedcMousePress *)buf;
+    case SPICE_MSGC_INPUTS_MOUSE_PRESS: {
+        SpiceMsgcMousePress *mouse_press = (SpiceMsgcMousePress *)buf;
         int dz = 0;
-        if (mouse_press->button == REDC_MOUSE_UBUTTON) {
+        if (mouse_press->button == SPICE_MOUSE_BUTTON_UP) {
             dz = -1;
-        } else if (mouse_press->button == REDC_MOUSE_DBUTTON) {
+        } else if (mouse_press->button == SPICE_MOUSE_BUTTON_DOWN) {
             dz = 1;
         }
-        if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT) {
+        if (reds->mouse_mode == SPICE_MOUSE_MODE_CLIENT) {
             if (agent_mouse && vdagent) {
                 reds->inputs_state->mouse_state.buttons =
                     RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state) |
@@ -2417,9 +2417,9 @@ static void inputs_handle_input(void *opaque, RedDataHeader *header)
         }
         break;
     }
-    case REDC_INPUTS_MOUSE_RELEASE: {
-        RedcMouseRelease *mouse_release = (RedcMouseRelease *)buf;
-        if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT) {
+    case SPICE_MSGC_INPUTS_MOUSE_RELEASE: {
+        SpiceMsgcMouseRelease *mouse_release = (SpiceMsgcMouseRelease *)buf;
+        if (reds->mouse_mode == SPICE_MOUSE_MODE_CLIENT) {
             if (agent_mouse && vdagent) {
                 reds->inputs_state->mouse_state.buttons =
                     RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
@@ -2432,29 +2432,29 @@ static void inputs_handle_input(void *opaque, RedDataHeader *header)
         }
         break;
     }
-    case REDC_INPUTS_KEY_MODIFAIERS: {
-        RedcKeyModifiers *modifiers = (RedcKeyModifiers *)buf;
+    case SPICE_MSGC_INPUTS_KEY_MODIFIERS: {
+        SpiceMsgcKeyModifiers *modifiers = (SpiceMsgcKeyModifiers *)buf;
         if (!keyboard) {
             break;
         }
         uint8_t leds = keyboard->get_leds(keyboard);
-        if ((modifiers->modifiers & RED_SCROLL_LOCK_MODIFIER) !=
-                                                                (leds & RED_SCROLL_LOCK_MODIFIER)) {
+        if ((modifiers->modifiers & SPICE_SCROLL_LOCK_MODIFIER) !=
+                                                                (leds & SPICE_SCROLL_LOCK_MODIFIER)) {
             push_key_scan(SCROLL_LOCK_SCAN_CODE);
             push_key_scan(SCROLL_LOCK_SCAN_CODE | 0x80);
         }
-        if ((modifiers->modifiers & RED_NUM_LOCK_MODIFIER) != (leds & RED_NUM_LOCK_MODIFIER)) {
+        if ((modifiers->modifiers & SPICE_NUM_LOCK_MODIFIER) != (leds & SPICE_NUM_LOCK_MODIFIER)) {
             push_key_scan(NUM_LOCK_SCAN_CODE);
             push_key_scan(NUM_LOCK_SCAN_CODE | 0x80);
         }
-        if ((modifiers->modifiers & RED_CAPS_LOCK_MODIFIER) != (leds & RED_CAPS_LOCK_MODIFIER)) {
+        if ((modifiers->modifiers & SPICE_CAPS_LOCK_MODIFIER) != (leds & SPICE_CAPS_LOCK_MODIFIER)) {
             push_key_scan(CAPS_LOCK_SCAN_CODE);
             push_key_scan(CAPS_LOCK_SCAN_CODE | 0x80);
         }
         activate_modifiers_watch();
         break;
     }
-    case REDC_DISCONNECTING:
+    case SPICE_MSGC_DISCONNECTING:
         break;
     default:
         red_printf("unexpected type %d", header->type);
@@ -2522,12 +2522,12 @@ static void inputs_shutdown(Channel *channel)
 static void inputs_migrate(Channel *channel)
 {
     InputsState *state = (InputsState *)channel->data;
-    RedDataHeader header;
-    RedMigrate migrate;
+    SpiceDataHeader header;
+    SpiceMsgMigrate migrate;
 
     red_printf("");
     header.serial = ++state->serial;
-    header.type = RED_MIGRATE;
+    header.type = SPICE_MSG_MIGRATE;
     header.size = sizeof(migrate);
     header.sub_list = 0;
     migrate.flags = 0;
@@ -2600,17 +2600,17 @@ static void inputs_link(Channel *channel, RedsStreamContext *peer, int migration
     reds->inputs_state = inputs_state;
     core->set_file_handlers(core, peer->socket, inputs_read, NULL, inputs_state);
 
-    RedDataHeader header;
-    RedInputsInit inputs_init;
+    SpiceDataHeader header;
+    SpiceMsgInputsInit inputs_init;
     header.serial = ++inputs_state->serial;
-    header.type = RED_INPUTS_INIT;
-    header.size = sizeof(RedInputsInit);
+    header.type = SPICE_MSG_INPUTS_INIT;
+    header.size = sizeof(SpiceMsgInputsInit);
     header.sub_list = 0;
     inputs_init.keyboard_modifiers = keyboard ? keyboard->get_leds(keyboard) : 0;
     if (outgoing_write(inputs_state->peer, &inputs_state->out_handler, &header,
-                       sizeof(RedDataHeader)) != OUTGOING_OK ||
+                       sizeof(SpiceDataHeader)) != OUTGOING_OK ||
         outgoing_write(inputs_state->peer, &inputs_state->out_handler, &inputs_init,
-                       sizeof(RedInputsInit)) != OUTGOING_OK) {
+                       sizeof(SpiceMsgInputsInit)) != OUTGOING_OK) {
         red_printf("failed to send modifiers state");
         reds_disconnect();
     }
@@ -2618,24 +2618,24 @@ static void inputs_link(Channel *channel, RedsStreamContext *peer, int migration
 
 static void reds_send_keyborad_modifiers(uint8_t modifiers)
 {
-    Channel *channel = reds_find_channel(RED_CHANNEL_INPUTS, 0);
+    Channel *channel = reds_find_channel(SPICE_CHANNEL_INPUTS, 0);
     InputsState *state;
 
     if (!channel || !(state = (InputsState *)channel->data)) {
         return;
     }
     ASSERT(state->peer);
-    RedDataHeader header;
-    RedKeyModifiers key_modifiers;
+    SpiceDataHeader header;
+    SpiceMsgInputsKeyModifiers key_modifiers;
     header.serial = ++state->serial;
-    header.type = RED_INPUTS_KEY_MODIFAIERS;
-    header.size = sizeof(RedKeyModifiers);
+    header.type = SPICE_MSG_INPUTS_KEY_MODIFIERS;
+    header.size = sizeof(SpiceMsgInputsKeyModifiers);
     header.sub_list = 0;
     key_modifiers.modifiers = modifiers;
 
-    if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+    if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(SpiceDataHeader))
                                                                                 != OUTGOING_OK ||
-        outgoing_write(state->peer, &state->out_handler, &key_modifiers, sizeof(RedKeyModifiers))
+        outgoing_write(state->peer, &state->out_handler, &key_modifiers, sizeof(SpiceMsgInputsKeyModifiers))
                                                                                 != OUTGOING_OK) {
         red_printf("failed to send modifiers state");
         reds_disconnect();
@@ -2666,7 +2666,7 @@ static void inputs_init()
         red_error("alloc inputs chanel failed");
     }
     memset(channel, 0, sizeof(Channel));
-    channel->type = RED_CHANNEL_INPUTS;
+    channel->type = SPICE_CHANNEL_INPUTS;
     channel->link = inputs_link;
     channel->shutdown = inputs_shutdown;
     channel->migrate = inputs_migrate;
@@ -2677,45 +2677,45 @@ static void reds_handle_other_links(RedLinkInfo *link)
 {
     Channel *channel;
     RedsStreamContext *peer;
-    RedLinkMess *link_mess;
+    SpiceLinkMess *link_mess;
     uint32_t *caps;
 
     link_mess = link->link_mess;
 
     if (!reds->link_id || reds->link_id != link_mess->connection_id) {
-        reds_send_link_result(link, RED_ERR_BAD_CONNECTION_ID);
+        reds_send_link_result(link, SPICE_LINK_ERR_BAD_CONNECTION_ID);
         reds_release_link(link);
         return;
     }
 
     if (!(channel = reds_find_channel(link_mess->channel_type,
                                       link_mess->channel_id))) {
-        reds_send_link_result(link, RED_ERR_CHANNEL_NOT_AVAILABLE);
+        reds_send_link_result(link, SPICE_LINK_ERR_CHANNEL_NOT_AVAILABLE);
         reds_release_link(link);
         return;
     }
 
-    reds_send_link_result(link, RED_ERR_OK);
+    reds_send_link_result(link, SPICE_LINK_ERR_OK);
     reds_show_new_channel(link);
-    if (link_mess->channel_type == RED_CHANNEL_INPUTS && !link->peer->ssl) {
+    if (link_mess->channel_type == SPICE_CHANNEL_INPUTS && !link->peer->ssl) {
         SimpleOutItem *item;
-        RedNotify *notify;
+        SpiceMsgNotify *notify;
         char *mess = "keybord channel is unsecure";
         const int mess_len = strlen(mess);
 
         LOG_MESSAGE(VD_LOG_WARN, "%s", mess);
 
-        if (!(item = new_simple_out_item(RED_NOTIFY, sizeof(RedNotify) + mess_len + 1))) {
+        if (!(item = new_simple_out_item(SPICE_MSG_NOTIFY, sizeof(SpiceMsgNotify) + mess_len + 1))) {
             red_printf("alloc item failed");
             reds_disconnect();
             return;
         }
 
-        notify = (RedNotify *)item->data;
+        notify = (SpiceMsgNotify *)item->data;
         notify->time_stamp = get_time_stamp();
-        notify->severty = RED_NOTIFY_SEVERITY_WARN;
-        notify->visibilty = RED_NOTIFY_VISIBILITY_HIGH;
-        notify->what = RED_WARN_GENERAL;
+        notify->severty = SPICE_NOTIFY_SEVERITY_WARN;
+        notify->visibilty = SPICE_NOTIFY_VISIBILITY_HIGH;
+        notify->what = SPICE_WARN_GENERAL;
         notify->message_len = mess_len;
         memcpy(notify->message, mess, mess_len + 1);
         reds_push_pipe_item(&item->base);
@@ -2733,7 +2733,7 @@ static void reds_handle_other_links(RedLinkInfo *link)
 static void reds_handle_ticket(void *opaque)
 {
     RedLinkInfo *link = (RedLinkInfo *)opaque;
-    char password[RED_MAX_PASSWORD_LENGTH];
+    char password[SPICE_MAX_PASSWORD_LENGTH];
     time_t ltime;
 
     //todo: use monotonic time
@@ -2747,21 +2747,21 @@ static void reds_handle_ticket(void *opaque)
         char *actual_sever_pass = link->link_mess->connection_id ? reds->taTicket.password :
                                                                    taTicket.password;
         if (strlen(actual_sever_pass) == 0) {
-            reds_send_link_result(link, RED_ERR_PERMISSION_DENIED);
+            reds_send_link_result(link, SPICE_LINK_ERR_PERMISSION_DENIED);
             red_printf("Ticketing is enabled, but no password is set. "
                        "please set a ticket first");
             reds_release_link(link);
             return;
         }
 
-        if (expired || strncmp(password, actual_sever_pass, RED_MAX_PASSWORD_LENGTH) != 0) {
-            reds_send_link_result(link, RED_ERR_PERMISSION_DENIED);
+        if (expired || strncmp(password, actual_sever_pass, SPICE_MAX_PASSWORD_LENGTH) != 0) {
+            reds_send_link_result(link, SPICE_LINK_ERR_PERMISSION_DENIED);
             LOG_MESSAGE(VD_LOG_WARN, "bad connection password or time expired");
             reds_release_link(link);
             return;
         }
     }
-    if (link->link_mess->channel_type == RED_CHANNEL_MAIN) {
+    if (link->link_mess->channel_type == SPICE_CHANNEL_MAIN) {
         reds_handle_main_link(link);
     } else {
         reds_handle_other_links(link);
@@ -2829,14 +2829,14 @@ static int reds_security_check(RedLinkInfo *link)
 static void reds_handle_read_link_done(void *opaque)
 {
     RedLinkInfo *link = (RedLinkInfo *)opaque;
-    RedLinkMess *link_mess = link->link_mess;
+    SpiceLinkMess *link_mess = link->link_mess;
     AsyncRead *obj = &link->asyc_read;
     uint32_t num_caps = link_mess->num_common_caps + link_mess->num_channel_caps;
 
     if (num_caps && (num_caps * sizeof(uint32_t) + link_mess->caps_offset >
                                                    link->link_header.size ||
                                                      link_mess->caps_offset < sizeof(*link_mess))) {
-        reds_send_link_error(link, RED_ERR_INVALID_DATA);
+        reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
         reds_release_link(link);
         return;
     }
@@ -2846,12 +2846,12 @@ static void reds_handle_read_link_done(void *opaque)
             LOG_MESSAGE(VD_LOG_INFO, "channels of type %d should connect only over "
                                      "a non secure link", link_mess->channel_type);
             red_printf("spice channels %d should not be encrypted", link_mess->channel_type);
-            reds_send_link_error(link, RED_ERR_NEED_UNSECURED);
+            reds_send_link_error(link, SPICE_LINK_ERR_NEED_UNSECURED);
         } else {
             LOG_MESSAGE(VD_LOG_INFO, "channels of type %d should connect only over "
                                      "a secure link", link_mess->channel_type);
             red_printf("spice channels %d should be encrypted", link_mess->channel_type);
-            reds_send_link_error(link, RED_ERR_NEED_SECURED);
+            reds_send_link_error(link, SPICE_LINK_ERR_NEED_SECURED);
         }
         reds_release_link(link);
         return;
@@ -2885,25 +2885,25 @@ static void reds_handle_link_error(void *opaque, int err)
 static void reds_handle_read_header_done(void *opaque)
 {
     RedLinkInfo *link = (RedLinkInfo *)opaque;
-    RedLinkHeader *header = &link->link_header;
+    SpiceLinkHeader *header = &link->link_header;
     AsyncRead *obj = &link->asyc_read;
 
-    if (header->magic != RED_MAGIC) {
-        reds_send_link_error(link, RED_ERR_INVALID_MAGIC);
+    if (header->magic != SPICE_MAGIC) {
+        reds_send_link_error(link, SPICE_LINK_ERR_INVALID_MAGIC);
         LOG_MESSAGE(VD_LOG_ERROR, "bad magic %u", header->magic);
         reds_release_link(link);
         return;
     }
 
-    if (header->major_version != RED_VERSION_MAJOR) {
+    if (header->major_version != SPICE_VERSION_MAJOR) {
         if (header->major_version > 0) {
-            reds_send_link_error(link, RED_ERR_VERSION_MISMATCH);
+            reds_send_link_error(link, SPICE_LINK_ERR_VERSION_MISMATCH);
         }
         LOG_MESSAGE(VD_LOG_INFO, "version mismatch client %u.%u server %u.%u",
                     header->major_version,
                     header->minor_version,
-                    RED_VERSION_MAJOR,
-                    RED_VERSION_MINOR);
+                    SPICE_VERSION_MAJOR,
+                    SPICE_VERSION_MINOR);
 
         red_printf("version mismatch");
         reds_release_link(link);
@@ -2912,8 +2912,8 @@ static void reds_handle_read_header_done(void *opaque)
 
     reds->peer_minor_version = header->minor_version;
 
-    if (header->size < sizeof(RedLinkMess)) {
-        reds_send_link_error(link, RED_ERR_INVALID_DATA);
+    if (header->size < sizeof(SpiceLinkMess)) {
+        reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
         red_printf("bad size %u", header->size);
         reds_release_link(link);
         return;
@@ -2937,7 +2937,7 @@ static void reds_handle_new_link(RedLinkInfo *link)
     obj->opaque = link;
     obj->peer = link->peer;
     obj->now = (uint8_t *)&link->link_header;
-    obj->end = (uint8_t *)((RedLinkHeader *)&link->link_header + 1);
+    obj->end = (uint8_t *)((SpiceLinkHeader *)&link->link_header + 1);
     obj->active_file_handlers = FALSE;
     obj->done = reds_handle_read_header_done;
     obj->error = reds_handle_link_error;
@@ -3853,27 +3853,27 @@ static int set_channels_security(const char *channels, uint32_t security)
             break;
         case CHANNEL_NAME_MAIN:
             specific++;
-            set_one_channel_security(RED_CHANNEL_MAIN, security);
+            set_one_channel_security(SPICE_CHANNEL_MAIN, security);
             break;
         case CHANNEL_NAME_DISPLAY:
             specific++;
-            set_one_channel_security(RED_CHANNEL_DISPLAY, security);
+            set_one_channel_security(SPICE_CHANNEL_DISPLAY, security);
             break;
         case CHANNEL_NAME_INPUTS:
             specific++;
-            set_one_channel_security(RED_CHANNEL_INPUTS, security);
+            set_one_channel_security(SPICE_CHANNEL_INPUTS, security);
             break;
         case CHANNEL_NAME_CURSOR:
             specific++;
-            set_one_channel_security(RED_CHANNEL_CURSOR, security);
+            set_one_channel_security(SPICE_CHANNEL_CURSOR, security);
             break;
         case CHANNEL_NAME_PLAYBACK:
             specific++;
-            set_one_channel_security(RED_CHANNEL_PLAYBACK, security);
+            set_one_channel_security(SPICE_CHANNEL_PLAYBACK, security);
             break;
         case CHANNEL_NAME_RECORD:
             specific++;
-            set_one_channel_security(RED_CHANNEL_RECORD, security);
+            set_one_channel_security(SPICE_CHANNEL_RECORD, security);
             break;
         default:
             goto error;
@@ -4172,7 +4172,7 @@ typedef struct RedsMigSpice {
     RedsMigWrite write;
     RedsMigRead read;
 
-    char pub_key[RED_TICKET_PUBKEY_BYTES];
+    char pub_key[SPICE_TICKET_PUBKEY_BYTES];
     uint32_t mig_key;
 
     char *local_args;
@@ -4294,27 +4294,27 @@ static void reds_mig_read(void *data)
 
 static void reds_mig_continue(RedsMigSpice *s)
 {
-    RedMigrationBegin *migrate;
+    SpiceMsgMainMigrationBegin *migrate;
     SimpleOutItem *item;
     int host_len;
 
     red_printf("");
     core->set_file_handlers(core, s->fd, NULL, NULL, NULL);
     host_len = strlen(s->host) + 1;
-    item = new_simple_out_item(RED_MIGRATE_BEGIN,
-                               sizeof(RedMigrationBegin) + host_len + s->cert_pub_key_len);
+    item = new_simple_out_item(SPICE_MSG_MAIN_MIGRATE_BEGIN,
+                               sizeof(SpiceMsgMainMigrationBegin) + host_len + s->cert_pub_key_len);
     if (!(item)) {
         red_printf("alloc item failed");
         reds_disconnect();
         return;
     }
-    migrate = (RedMigrationBegin *)item->data;
+    migrate = (SpiceMsgMainMigrationBegin *)item->data;
     migrate->port = s->port;
     migrate->sport = s->sport;
-    migrate->host_offset = sizeof(RedMigrationBegin);
+    migrate->host_offset = sizeof(SpiceMsgMainMigrationBegin);
     migrate->host_size = host_len;
     migrate->pub_key_type = s->cert_pub_key_type;
-    migrate->pub_key_offset = sizeof(RedMigrationBegin) + host_len;
+    migrate->pub_key_offset = sizeof(SpiceMsgMainMigrationBegin) + host_len;
     migrate->pub_key_size = s->cert_pub_key_len;
     memcpy((uint8_t*)(migrate) + migrate->host_offset , s->host, host_len);
     memcpy((uint8_t*)(migrate) + migrate->pub_key_offset, s->cert_pub_key, s->cert_pub_key_len);
@@ -4359,7 +4359,7 @@ static void reds_mig_send_ticket(RedsMigSpice *s)
 
     bio_key = BIO_new(BIO_s_mem());
     if (bio_key != NULL) {
-        BIO_write(bio_key, s->read.buf, RED_TICKET_PUBKEY_BYTES);
+        BIO_write(bio_key, s->read.buf, SPICE_TICKET_PUBKEY_BYTES);
         pubkey = d2i_PUBKEY_bio(bio_key, NULL);
         rsa = pubkey->pkey.rsa;
         rsa_size = RSA_size(rsa);
@@ -4393,7 +4393,7 @@ static void reds_mig_receive_cert_public_key(RedsMigSpice *s)
 
     memcpy(s->cert_pub_key, s->read.buf, s->cert_pub_key_len);
 
-    s->read.size = RED_TICKET_PUBKEY_BYTES;
+    s->read.size = SPICE_TICKET_PUBKEY_BYTES;
     s->read.end_pos = 0;
     s->read.handle_data = reds_mig_send_ticket;
 
@@ -4418,7 +4418,7 @@ static void reds_mig_receive_cert_public_key_info(RedsMigSpice *s)
         s->read.handle_data = reds_mig_receive_cert_public_key;
     } else {
         s->cert_pub_key = NULL;
-        s->read.size = RED_TICKET_PUBKEY_BYTES;
+        s->read.size = SPICE_TICKET_PUBKEY_BYTES;
         s->read.end_pos = 0;
         s->read.handle_data = reds_mig_send_ticket;
     }
@@ -4514,9 +4514,9 @@ static void reds_mig_started(void *opaque, const char *in_args)
         goto error;
     }
 
-    if ((RED_VERSION_MAJOR == 1) && (reds->peer_minor_version < 2)) {
+    if ((SPICE_VERSION_MAJOR == 1) && (reds->peer_minor_version < 2)) {
         red_printf("minor version mismatch client %u server %u",
-                   reds->peer_minor_version, RED_VERSION_MINOR);
+                   reds->peer_minor_version, SPICE_VERSION_MINOR);
         goto error;
     }
 
@@ -4633,18 +4633,18 @@ static void reds_mig_finished(void *opaque, int completed)
 
     if (completed) {
         Channel *channel;
-        RedMigrate *migrate;
+        SpiceMsgMigrate *migrate;
 
         reds->mig_wait_disconnect = TRUE;
         core->arm_timer(core, reds->mig_timer, MIGRATE_TIMEOUT);
 
-        if (!(item = new_simple_out_item(RED_MIGRATE, sizeof(RedMigrate)))) {
+        if (!(item = new_simple_out_item(SPICE_MSG_MIGRATE, sizeof(SpiceMsgMigrate)))) {
             red_printf("alloc item failed");
             reds_disconnect();
             return;
         }
-        migrate = (RedMigrate *)item->data;
-        migrate->flags = RED_MIGRATE_NEED_FLUSH | RED_MIGRATE_NEED_DATA_TRANSFER;
+        migrate = (SpiceMsgMigrate *)item->data;
+        migrate->flags = SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER;
         reds_push_pipe_item(&item->base);
         channel = reds->channels;
         while (channel) {
@@ -4652,7 +4652,7 @@ static void reds_mig_finished(void *opaque, int completed)
             channel = channel->next;
         }
     } else {
-        if (!(item = new_simple_out_item(RED_MIGRATE_CANCEL, 0))) {
+        if (!(item = new_simple_out_item(SPICE_MSG_MAIN_MIGRATE_CANCEL, 0))) {
             red_printf("alloc item failed");
             reds_disconnect();
             return;
@@ -4733,7 +4733,7 @@ static void reds_mig_send_cert_public_key(int fd)
     RedsMigCertPubKeyInfo pub_key_info_msg;
 
     if (spice_secure_port == -1) {
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_INVALID;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_INVALID;
         pub_key_info_msg.len = 0;
         reds_mig_write_all(fd, &pub_key_info_msg, sizeof(pub_key_info_msg), "cert public key info");
         return;
@@ -4762,31 +4762,31 @@ static void reds_mig_send_cert_public_key(int fd)
 
     switch(pub_key->type) {
     case EVP_PKEY_RSA:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_RSA;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_RSA;
         break;
     case EVP_PKEY_RSA2:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_RSA2;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_RSA2;
         break;
     case EVP_PKEY_DSA:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_DSA;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_DSA;
         break;
     case EVP_PKEY_DSA1:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_DSA1;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_DSA1;
         break;
     case EVP_PKEY_DSA2:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_DSA2;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_DSA2;
         break;
     case EVP_PKEY_DSA3:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_DSA3;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_DSA3;
         break;
     case EVP_PKEY_DSA4:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_DSA4;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_DSA4;
         break;
     case EVP_PKEY_DH:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_DH;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_DH;
         break;
     case EVP_PKEY_EC:
-        pub_key_info_msg.type = RED_PUBKEY_TYPE_EC;
+        pub_key_info_msg.type = SPICE_PUBKEY_TYPE_EC;
         break;
     default:
         red_error("invalid public key type");
@@ -4804,7 +4804,7 @@ static void reds_mig_send_cert_public_key(int fd)
 static void reds_mig_recv(void *opaque, int fd)
 {
     uint32_t ack_message = *(uint32_t *)"ack_";
-    char password[RED_MAX_PASSWORD_LENGTH];
+    char password[SPICE_MAX_PASSWORD_LENGTH];
     RedsMigSpiceMessage mig_message;
     unsigned long f4 = RSA_F4;
     TicketInfo ticketing_info;
@@ -4856,7 +4856,7 @@ static void reds_mig_recv(void *opaque, int fd)
         red_error("OpenSSL RSA alloc failed");
     }
 
-    RSA_generate_key_ex(ticketing_info.rsa, RED_TICKET_KEY_PAIR_LENGTH, ticketing_info.bn, NULL);
+    RSA_generate_key_ex(ticketing_info.rsa, SPICE_TICKET_KEY_PAIR_LENGTH, ticketing_info.bn, NULL);
     ticketing_info.rsa_size = RSA_size(ticketing_info.rsa);
 
     if (!(bio = BIO_new(BIO_s_mem()))) {
@@ -4866,7 +4866,7 @@ static void reds_mig_recv(void *opaque, int fd)
     i2d_RSA_PUBKEY_bio(bio, ticketing_info.rsa);
     BIO_get_mem_ptr(bio, &buff);
 
-    reds_mig_write_all(fd, buff->data, RED_TICKET_PUBKEY_BYTES, "publick key");
+    reds_mig_write_all(fd, buff->data, SPICE_TICKET_PUBKEY_BYTES, "publick key");
     reds_mig_read_all(fd, ticketing_info.encrypted_ticket.encrypted_data, ticketing_info.rsa_size,
                       "ticket");
 
@@ -4910,7 +4910,7 @@ void reds_update_mm_timer(uint32_t mm_time)
 
 void reds_enable_mm_timer()
 {
-    RedMultiMediaTime *time_mes;
+    SpiceMsgMainMultiMediaTime *time_mes;
     SimpleOutItem *item;
 
     core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
@@ -4918,12 +4918,12 @@ void reds_enable_mm_timer()
         return;
     }
 
-    if (!(item = new_simple_out_item(RED_MULTI_MEDIA_TIME, sizeof(RedMultiMediaTime)))) {
+    if (!(item = new_simple_out_item(SPICE_MSG_MAIN_MULTI_MEDIA_TIME, sizeof(SpiceMsgMainMultiMediaTime)))) {
         red_printf("alloc item failed");
         reds_disconnect();
         return;
     }
-    time_mes = (RedMultiMediaTime *)item->data;
+    time_mes = (SpiceMsgMainMultiMediaTime *)item->data;
     time_mes->time = reds_get_mm_time() - MM_TIME_DELTA;
     reds_push_pipe_item(&item->base);
 }
@@ -5375,7 +5375,7 @@ static void init_vd_agent_resources()
         memset(buf, 0, sizeof(*buf));
         buf->out_item.prepare = reds_prepare_read_buf;
         buf->out_item.release = reds_release_read_buf;
-        buf->header.type = RED_AGENT_DATA;
+        buf->header.type = SPICE_MSG_MAIN_AGENT_DATA;
         buf->header.sub_list = 0;
         ring_item_init(&buf->out_item.link);
         ring_add(&reds->agent_state.read_bufs, &buf->out_item.link);
@@ -5431,13 +5431,13 @@ void __attribute__ ((visibility ("default"))) spice_init(CoreInterface *core_int
     core->register_change_notifiers(core, &reds, interface_change_notifier);
 
 #ifdef RED_STATISTICS
-    int shm_name_len = strlen(REDS_STAT_SHM_NAME) + 20;
+    int shm_name_len = strlen(SPICE_STAT_SHM_NAME) + 20;
     int fd;
 
     if (!(reds->stat_shm_name = (char *)malloc(shm_name_len))) {
         red_error("stat_shm_name alloc failed");
     }
-    snprintf(reds->stat_shm_name, shm_name_len, REDS_STAT_SHM_NAME, getpid());
+    snprintf(reds->stat_shm_name, shm_name_len, SPICE_STAT_SHM_NAME, getpid());
     if ((fd = shm_open(reds->stat_shm_name, O_CREAT | O_RDWR, 0444)) == -1) {
         red_error("statistics shm_open failed, %s", strerror(errno));
     }
@@ -5445,12 +5445,12 @@ void __attribute__ ((visibility ("default"))) spice_init(CoreInterface *core_int
         red_error("statistics ftruncate failed, %s", strerror(errno));
     }
     reds->stat = mmap(NULL, REDS_STAT_SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (reds->stat == (RedsStat *)MAP_FAILED) {
+    if (reds->stat == (SpiceStat *)MAP_FAILED) {
         red_error("statistics mmap failed, %s", strerror(errno));
     }
     memset(reds->stat, 0, REDS_STAT_SHM_SIZE);
-    reds->stat->magic = REDS_STAT_MAGIC;
-    reds->stat->version = REDS_STAT_VERSION;
+    reds->stat->magic = SPICE_STAT_MAGIC;
+    reds->stat->version = SPICE_STAT_VERSION;
     reds->stat->root_index = INVALID_STAT_REF;
     if (pthread_mutex_init(&reds->stat_lock, NULL)) {
         red_error("mutex init failed");
@@ -5472,7 +5472,7 @@ void __attribute__ ((visibility ("default"))) spice_init(CoreInterface *core_int
     }
     inputs_init();
 
-    reds->mouse_mode = RED_MOUSE_MODE_SERVER;
+    reds->mouse_mode = SPICE_MOUSE_MODE_SERVER;
     atexit(reds_exit);
 }
 
diff --git a/server/snd_worker.c b/server/snd_worker.c
index 8cfabaef..3046bd1b 100644
--- a/server/snd_worker.c
+++ b/server/snd_worker.c
@@ -68,7 +68,7 @@ typedef struct BufDescriptor {
 
 typedef struct SndChannel SndChannel;
 typedef void (*send_messages_proc)(void *in_channel);
-typedef int (*handle_message_proc)(SndChannel *channel, RedDataHeader *message);
+typedef int (*handle_message_proc)(SndChannel *channel, SpiceDataHeader *message);
 typedef void (*on_message_done_proc)(SndChannel *channel);
 typedef void (*cleanup_channel_proc)(SndChannel *channel);
 
@@ -90,7 +90,7 @@ struct SndChannel {
     uint32_t ack_messages;
 
     struct {
-        RedDataHeader header;
+        SpiceDataHeader header;
         uint32_t n_bufs;
         BufDescriptor bufs[MAX_SEND_BUFS];
 
@@ -100,7 +100,7 @@ struct SndChannel {
 
     struct {
         uint8_t buf[RECIVE_BUF_SIZE];
-        RedDataHeader *message;
+        SpiceDataHeader *message;
         uint8_t *now;
         uint8_t *end;
     } recive_data;
@@ -132,9 +132,9 @@ typedef struct PlaybackChannel {
     uint32_t mode;
     struct {
         union {
-            RedPlaybackMode mode;
-            RedPlaybackStart start;
-            RedMigrate migrate;
+            SpiceMsgPlaybackMode mode;
+            SpiceMsgPlaybackStart start;
+            SpiceMsgMigrate migrate;
             uint8_t celt_buf[CELT_COMPRESSED_FRAME_BYTES];
         } u;
     } send_data;
@@ -158,8 +158,8 @@ typedef struct __attribute__ ((__packed__)) RecordMigrateData {
 } RecordMigrateData;
 
 typedef struct __attribute__ ((__packed__)) RecordMigrateMessage {
-    RedMigrate migrate;
-    RedDataHeader header;
+    SpiceMsgMigrate migrate;
+    SpiceDataHeader header;
     RecordMigrateData data;
 } RecordMigrateMessage;
 
@@ -178,14 +178,14 @@ typedef struct RecordChannel {
     uint32_t celt_buf[FRAME_SIZE];
     struct {
         union {
-            RedRecordStart start;
+            SpiceMsgRecordStart start;
             RecordMigrateMessage migrate;
         } u;
     } send_data;
 } RecordChannel;
 
 static SndWorker *workers = NULL;
-static uint32_t playback_compression = RED_AUDIO_DATA_MODE_CELT_0_5_1;
+static uint32_t playback_compression = SPICE_AUDIO_DATA_MODE_CELT_0_5_1;
 
 static void snd_receive(void* data);
 
@@ -323,9 +323,9 @@ static int snd_send_data(SndChannel *channel)
     return TRUE;
 }
 
-static int snd_record_handle_write(RecordChannel *record_channel, RedDataHeader *message)
+static int snd_record_handle_write(RecordChannel *record_channel, SpiceDataHeader *message)
 {
-    RedcRecordPacket *packet;
+    SpiceMsgcRecordPacket *packet;
     uint32_t write_pos;
     uint32_t* data;
     uint32_t size;
@@ -336,10 +336,10 @@ static int snd_record_handle_write(RecordChannel *record_channel, RedDataHeader
         return FALSE;
     }
 
-    packet = (RedcRecordPacket *)(message + 1);
+    packet = (SpiceMsgcRecordPacket *)(message + 1);
     size = message->size - sizeof(*packet);
 
-    if (record_channel->mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+    if (record_channel->mode == SPICE_AUDIO_DATA_MODE_CELT_0_5_1) {
         int celt_err = celt051_decode(record_channel->celt_decoder, packet->data, size,
                                       (celt_int16_t *)record_channel->celt_buf);
         if (celt_err != CELT_OK) {
@@ -348,7 +348,7 @@ static int snd_record_handle_write(RecordChannel *record_channel, RedDataHeader
         }
         data = record_channel->celt_buf;
         size = FRAME_SIZE;
-    } else if (record_channel->mode == RED_AUDIO_DATA_MODE_RAW) {
+    } else if (record_channel->mode == SPICE_AUDIO_DATA_MODE_RAW) {
         data = (uint32_t *)packet->data;
         size = size >> 2;
         size = MIN(size, RECORD_SAMPLES_SIZE);
@@ -373,14 +373,14 @@ static int snd_record_handle_write(RecordChannel *record_channel, RedDataHeader
     return TRUE;
 }
 
-static int snd_playback_handle_message(SndChannel *channel, RedDataHeader *message)
+static int snd_playback_handle_message(SndChannel *channel, SpiceDataHeader *message)
 {
     if (!channel) {
         return FALSE;
     }
 
     switch (message->type) {
-    case REDC_DISCONNECTING:
+    case SPICE_MSGC_DISCONNECTING:
         break;
     default:
         red_printf("invalid message type %u", message->type);
@@ -389,7 +389,7 @@ static int snd_playback_handle_message(SndChannel *channel, RedDataHeader *messa
     return TRUE;
 }
 
-static int snd_record_handle_message(SndChannel *channel, RedDataHeader *message)
+static int snd_record_handle_message(SndChannel *channel, SpiceDataHeader *message)
 {
     RecordChannel *record_channel = (RecordChannel *)channel;
 
@@ -397,26 +397,26 @@ static int snd_record_handle_message(SndChannel *channel, RedDataHeader *message
         return FALSE;
     }
     switch (message->type) {
-    case REDC_RECORD_DATA:
+    case SPICE_MSGC_RECORD_DATA:
         return snd_record_handle_write((RecordChannel *)channel, message);
-    case REDC_RECORD_MODE: {
-        RedcRecordMode *mode = (RedcRecordMode *)(message + 1);
+    case SPICE_MSGC_RECORD_MODE: {
+        SpiceMsgcRecordMode *mode = (SpiceMsgcRecordMode *)(message + 1);
         record_channel->mode = mode->mode;
         record_channel->mode_time = mode->time;
-        if (record_channel->mode != RED_AUDIO_DATA_MODE_CELT_0_5_1 &&
-                                                  record_channel->mode != RED_AUDIO_DATA_MODE_RAW) {
+        if (record_channel->mode != SPICE_AUDIO_DATA_MODE_CELT_0_5_1 &&
+                                                  record_channel->mode != SPICE_AUDIO_DATA_MODE_RAW) {
             red_printf("unsupported mode");
         }
         break;
     }
-    case REDC_RECORD_START_MARK: {
-        RedcRecordStartMark *mark = (RedcRecordStartMark *)(message + 1);
+    case SPICE_MSGC_RECORD_START_MARK: {
+        SpiceMsgcRecordStartMark *mark = (SpiceMsgcRecordStartMark *)(message + 1);
         record_channel->start_time = mark->time;
         break;
     }
-    case REDC_DISCONNECTING:
+    case SPICE_MSGC_DISCONNECTING:
         break;
-    case REDC_MIGRATE_DATA: {
+    case SPICE_MSGC_MIGRATE_DATA: {
         RecordMigrateData* mig_data = (RecordMigrateData *)(message + 1);
         if (mig_data->version != RECORD_MIG_VERSION) {
             red_printf("invalid mig version");
@@ -467,26 +467,26 @@ static void snd_receive(void* data)
         } else {
             channel->recive_data.now += n;
             for (;;) {
-                RedDataHeader *message = channel->recive_data.message;
+                SpiceDataHeader *message = channel->recive_data.message;
                 n = channel->recive_data.now - (uint8_t *)message;
-                if (n < sizeof(RedDataHeader) || n < sizeof(RedDataHeader) + message->size) {
+                if (n < sizeof(SpiceDataHeader) || n < sizeof(SpiceDataHeader) + message->size) {
                     break;
                 }
                 if (!channel->handle_message(channel, message)) {
                     snd_disconnect_channel(channel);
                     return;
                 }
-                channel->recive_data.message = (RedDataHeader *)((uint8_t *)message +
-                                                                 sizeof(RedDataHeader) +
+                channel->recive_data.message = (SpiceDataHeader *)((uint8_t *)message +
+                                                                 sizeof(SpiceDataHeader) +
                                                                  message->size);
             }
             if (channel->recive_data.now == (uint8_t *)channel->recive_data.message) {
                 channel->recive_data.now = channel->recive_data.buf;
-                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+                channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf;
             } else if (channel->recive_data.now == channel->recive_data.end) {
                 memcpy(channel->recive_data.buf, channel->recive_data.message, n);
                 channel->recive_data.now = channel->recive_data.buf + n;
-                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+                channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf;
             }
         }
     }
@@ -518,27 +518,27 @@ static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb)
     channel->send_data.header.size = 0;
     channel->send_data.header.type = verb;
     ++channel->send_data.header.serial;
-    __snd_add_buf(channel, &channel->send_data.header, sizeof(RedDataHeader));
+    __snd_add_buf(channel, &channel->send_data.header, sizeof(SpiceDataHeader));
     return TRUE;
 }
 
 static int snd_playback_send_migrate(PlaybackChannel *channel)
 {
-    if (!snd_reset_send_data((SndChannel *)channel, RED_MIGRATE)) {
+    if (!snd_reset_send_data((SndChannel *)channel, SPICE_MSG_MIGRATE)) {
         return FALSE;
     }
     channel->send_data.u.migrate.flags = 0;
     snd_add_buf((SndChannel *)channel, &channel->send_data.u.migrate,
                 sizeof(channel->send_data.u.migrate));
-    channel->base.send_data.size = channel->base.send_data.header.size + sizeof(RedDataHeader);
+    channel->base.send_data.size = channel->base.send_data.header.size + sizeof(SpiceDataHeader);
     return snd_send_data((SndChannel *)channel);
 }
 
 static int snd_playback_send_start(PlaybackChannel *playback_channel)
 {
     SndChannel *channel = (SndChannel *)playback_channel;
-    RedPlaybackStart *start;
-    if (!snd_reset_send_data(channel, RED_PLAYBACK_START)) {
+    SpiceMsgPlaybackStart *start;
+    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_START)) {
         return FALSE;
     }
 
@@ -546,21 +546,21 @@ static int snd_playback_send_start(PlaybackChannel *playback_channel)
     start->channels = VD_INTERFACE_PLAYBACK_CHAN;
     start->frequency = VD_INTERFACE_PLAYBACK_FREQ;
     ASSERT(VD_INTERFACE_PLAYBACK_FMT == VD_INTERFACE_AUDIO_FMT_S16);
-    start->format = RED_AUDIO_FMT_S16;
+    start->format = SPICE_AUDIO_FMT_S16;
     start->time = reds_get_mm_time();
     snd_add_buf(channel, start, sizeof(*start));
 
-    channel->send_data.size = sizeof(RedDataHeader) + sizeof(*start);
+    channel->send_data.size = sizeof(SpiceDataHeader) + sizeof(*start);
     return snd_send_data(channel);
 }
 
 static int snd_playback_send_stop(PlaybackChannel *playback_channel)
 {
     SndChannel *channel = (SndChannel *)playback_channel;
-    if (!snd_reset_send_data(channel, RED_PLAYBACK_STOP)) {
+    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_STOP)) {
         return FALSE;
     }
-    channel->send_data.size = sizeof(RedDataHeader);
+    channel->send_data.size = sizeof(SpiceDataHeader);
     return snd_send_data(channel);
 }
 
@@ -578,8 +578,8 @@ static int snd_playback_send_ctl(PlaybackChannel *playback_channel)
 static int snd_record_send_start(RecordChannel *record_channel)
 {
     SndChannel *channel = (SndChannel *)record_channel;
-    RedRecordStart *start;
-    if (!snd_reset_send_data(channel, RED_RECORD_START)) {
+    SpiceMsgRecordStart *start;
+    if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_START)) {
         return FALSE;
     }
 
@@ -587,20 +587,20 @@ static int snd_record_send_start(RecordChannel *record_channel)
     start->channels = VD_INTERFACE_RECORD_CHAN;
     start->frequency = VD_INTERFACE_RECORD_FREQ;
     ASSERT(VD_INTERFACE_RECORD_FMT == VD_INTERFACE_AUDIO_FMT_S16);
-    start->format = RED_AUDIO_FMT_S16;
+    start->format = SPICE_AUDIO_FMT_S16;
     snd_add_buf(channel, start, sizeof(*start));
 
-    channel->send_data.size = sizeof(RedDataHeader) + sizeof(*start);
+    channel->send_data.size = sizeof(SpiceDataHeader) + sizeof(*start);
     return snd_send_data(channel);
 }
 
 static int snd_record_send_stop(RecordChannel *record_channel)
 {
     SndChannel *channel = (SndChannel *)record_channel;
-    if (!snd_reset_send_data(channel, RED_RECORD_STOP)) {
+    if (!snd_reset_send_data(channel, SPICE_MSG_RECORD_STOP)) {
         return FALSE;
     }
-    channel->send_data.size = sizeof(RedDataHeader);
+    channel->send_data.size = sizeof(SpiceDataHeader);
     return snd_send_data(channel);
 }
 
@@ -620,13 +620,13 @@ static int snd_record_send_migrate(RecordChannel *record_channel)
     SndChannel *channel = (SndChannel *)record_channel;
     RecordMigrateMessage* migrate;
 
-    if (!snd_reset_send_data(channel, RED_MIGRATE)) {
+    if (!snd_reset_send_data(channel, SPICE_MSG_MIGRATE)) {
         return FALSE;
     }
 
     migrate = &record_channel->send_data.u.migrate;
-    migrate->migrate.flags = RED_MIGRATE_NEED_DATA_TRANSFER;
-    migrate->header.type = RED_MIGRATE_DATA;
+    migrate->migrate.flags = SPICE_MIGRATE_NEED_DATA_TRANSFER;
+    migrate->header.type = SPICE_MSG_MIGRATE_DATA;
     migrate->header.size = sizeof(RecordMigrateData);
     migrate->header.serial = ++channel->send_data.header.serial;
     migrate->header.sub_list = 0;
@@ -638,7 +638,7 @@ static int snd_record_send_migrate(RecordChannel *record_channel)
     migrate->data.mode_time = record_channel->mode_time;
 
     snd_add_buf(channel, migrate, sizeof(*migrate));
-    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->send_data.size = channel->send_data.header.size + sizeof(SpiceDataHeader);
     channel->send_data.header.size -= sizeof(migrate->header);
     channel->send_data.header.size -= sizeof(migrate->data);
     return snd_send_data(channel);
@@ -649,13 +649,13 @@ static int snd_playback_send_write(PlaybackChannel *playback_channel)
     SndChannel *channel = (SndChannel *)playback_channel;
     AudioFrame *frame;
 
-    if (!snd_reset_send_data(channel, RED_PLAYBACK_DATA)) {
+    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_DATA)) {
         return FALSE;
     }
 
     frame = playback_channel->in_progress;
     snd_add_buf(channel, &frame->time, sizeof(frame->time));
-    if (playback_channel->mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+    if (playback_channel->mode == SPICE_AUDIO_DATA_MODE_CELT_0_5_1) {
         int n = celt051_encode(playback_channel->celt_encoder, (celt_int16_t *)frame->samples, NULL,
                                playback_channel->send_data.u.celt_buf, CELT_COMPRESSED_FRAME_BYTES);
         if (n < 0) {
@@ -668,7 +668,7 @@ static int snd_playback_send_write(PlaybackChannel *playback_channel)
         snd_add_buf(channel, frame->samples, sizeof(frame->samples));
     }
 
-    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->send_data.size = channel->send_data.header.size + sizeof(SpiceDataHeader);
 
     return snd_send_data(channel);
 }
@@ -676,9 +676,9 @@ static int snd_playback_send_write(PlaybackChannel *playback_channel)
 static int playback_send_mode(PlaybackChannel *playback_channel)
 {
     SndChannel *channel = (SndChannel *)playback_channel;
-    RedPlaybackMode *mode;
+    SpiceMsgPlaybackMode *mode;
 
-    if (!snd_reset_send_data(channel, RED_PLAYBACK_MODE)) {
+    if (!snd_reset_send_data(channel, SPICE_MSG_PLAYBACK_MODE)) {
         return FALSE;
     }
     mode = &playback_channel->send_data.u.mode;
@@ -686,7 +686,7 @@ static int playback_send_mode(PlaybackChannel *playback_channel)
     mode->mode = playback_channel->mode;
     snd_add_buf(channel, mode, sizeof(*mode));
 
-    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->send_data.size = channel->send_data.header.size + sizeof(SpiceDataHeader);
     return snd_send_data(channel);
 }
 
@@ -802,7 +802,7 @@ static SndChannel *__new_channel(SndWorker *worker, int size, RedsStreamContext
     memset(channel, 0, size);
     channel->peer = peer;
     channel->worker = worker;
-    channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+    channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf;
     channel->recive_data.now = channel->recive_data.buf;
     channel->recive_data.end = channel->recive_data.buf + sizeof(channel->recive_data.buf);
 
@@ -989,9 +989,9 @@ static void snd_set_playback_peer(Channel *channel, RedsStreamContext *peer, int
     playback_channel->plug.put_frame = snd_playback_put_frame;
     playback_channel->celt_mode = celt_mode;
     playback_channel->celt_encoder = celt_encoder;
-    playback_channel->celt_allowed = num_caps > 0 && (caps[0] & (1 << RED_PLAYBACK_CAP_CELT_0_5_1));
+    playback_channel->celt_allowed = num_caps > 0 && (caps[0] & (1 << SPICE_PLAYBACK_CAP_CELT_0_5_1));
     playback_channel->mode = playback_channel->celt_allowed ? playback_compression :
-                                                              RED_AUDIO_DATA_MODE_RAW;
+                                                              SPICE_AUDIO_DATA_MODE_RAW;
 
     on_new_playback_channel(worker);
     snd_playback_send(worker->connection);
@@ -1205,7 +1205,7 @@ void snd_attach_playback(PlaybackInterface *interface)
         red_error("playback channel malloc failed");
     }
     memset(playback_worker, 0, sizeof(*playback_worker));
-    playback_worker->base.type = RED_CHANNEL_PLAYBACK;
+    playback_worker->base.type = SPICE_CHANNEL_PLAYBACK;
     playback_worker->base.link = snd_set_playback_peer;
     playback_worker->base.shutdown = snd_shutdown;
     playback_worker->base.migrate = snd_playback_migrate;
@@ -1216,7 +1216,7 @@ void snd_attach_playback(PlaybackInterface *interface)
     if (!(playback_worker->base.caps = malloc(sizeof(uint32_t)))) {
         PANIC("malloc failed");
     }
-    playback_worker->base.caps[0] = (1 << RED_PLAYBACK_CAP_CELT_0_5_1);
+    playback_worker->base.caps[0] = (1 << SPICE_PLAYBACK_CAP_CELT_0_5_1);
 
     add_worker(playback_worker);
     reds_register_channel(&playback_worker->base);
@@ -1230,7 +1230,7 @@ void snd_attach_record(RecordInterface *interface)
     }
 
     memset(record_worker, 0, sizeof(*record_worker));
-    record_worker->base.type = RED_CHANNEL_RECORD;
+    record_worker->base.type = SPICE_CHANNEL_RECORD;
     record_worker->base.link = snd_set_record_peer;
     record_worker->base.shutdown = snd_shutdown;
     record_worker->base.migrate = snd_record_migrate;
@@ -1242,7 +1242,7 @@ void snd_attach_record(RecordInterface *interface)
     if (!(record_worker->base.caps = malloc(sizeof(uint32_t)))) {
         PANIC("malloc failed");
     }
-    record_worker->base.caps[0] = (1 << RED_RECORD_CAP_CELT_0_5_1);
+    record_worker->base.caps[0] = (1 << SPICE_RECORD_CAP_CELT_0_5_1);
     add_worker(record_worker);
     reds_register_channel(&record_worker->base);
 }
@@ -1277,12 +1277,12 @@ void snd_set_playback_compression(int on)
 {
     SndWorker *now = workers;
 
-    playback_compression = on ? RED_AUDIO_DATA_MODE_CELT_0_5_1 : RED_AUDIO_DATA_MODE_RAW;
+    playback_compression = on ? SPICE_AUDIO_DATA_MODE_CELT_0_5_1 : SPICE_AUDIO_DATA_MODE_RAW;
     for (; now; now = now->next) {
-        if (now->base.type == RED_CHANNEL_PLAYBACK && now->connection) {
+        if (now->base.type == SPICE_CHANNEL_PLAYBACK && now->connection) {
             PlaybackChannel* playback = (PlaybackChannel*)now->connection;
             if (!playback->celt_allowed) {
-                ASSERT(playback->mode == RED_AUDIO_DATA_MODE_RAW);
+                ASSERT(playback->mode == SPICE_AUDIO_DATA_MODE_RAW);
                 continue;
             }
             if (playback->mode != playback_compression) {
@@ -1295,6 +1295,6 @@ void snd_set_playback_compression(int on)
 
 int snd_get_playback_compression()
 {
-    return (playback_compression == RED_AUDIO_DATA_MODE_RAW) ? FALSE : TRUE;
+    return (playback_compression == SPICE_AUDIO_DATA_MODE_RAW) ? FALSE : TRUE;
 }
 
diff --git a/server/vd_interface.h b/server/vd_interface.h
index 3adbf7e6..674fae00 100644
--- a/server/vd_interface.h
+++ b/server/vd_interface.h
@@ -196,7 +196,7 @@ struct QXLInterface {
     void (*release_resource)(QXLInterface *qxl, struct QXLReleaseInfoExt release_info);
     int (*get_cursor_command)(QXLInterface *qxl, struct QXLCommandExt *cmd);
     int (*req_cursor_notification)(QXLInterface *qxl);
-    const struct Rect *(*get_update_area)(QXLInterface *qxl);
+    const struct SpiceRect *(*get_update_area)(QXLInterface *qxl);
     void (*notify_update)(QXLInterface *qxl, uint32_t update_id);
     void (*set_save_data)(QXLInterface *qxl, void *data, int size);
     void *(*get_save_data)(QXLInterface *qxl);
diff --git a/tools/reds_stat.c b/tools/reds_stat.c
index 76541579..f77d8db0 100644
--- a/tools/reds_stat.c
+++ b/tools/reds_stat.c
@@ -29,17 +29,17 @@
 #define VALUE_TABS 7
 #define INVALID_STAT_REF (~(uint32_t)0)
 
-static RedsStat *reds_stat = NULL;
+static SpiceStat *reds_stat = NULL;
 static uint64_t *values = NULL;
 
 void print_stat_tree(int32_t node_index, int depth)
 {
-    StatNode *node = &reds_stat->nodes[node_index];
+    SpiceStatNode *node = &reds_stat->nodes[node_index];
     int i;
 
-    if ((node->flags & STAT_NODE_MASK_SHOW) == STAT_NODE_MASK_SHOW) {
+    if ((node->flags & SPICE_STAT_NODE_MASK_SHOW) == SPICE_STAT_NODE_MASK_SHOW) {
         printf("%*s%s", depth * TAB_LEN, "", node->name);
-        if (node->flags & STAT_NODE_FLAG_VALUE) {
+        if (node->flags & SPICE_STAT_NODE_FLAG_VALUE) {
             printf(":%*s%llu (%llu)\n", (VALUE_TABS - depth) * TAB_LEN - strlen(node->name) - 1, "",
                    node->value, node->value - values[node_index]);
             values[node_index] = node->value;
@@ -71,28 +71,28 @@ int main(int argc, char **argv)
         printf("usage: reds_stat [qemu_pid] (e.g. `pgrep qemu`)\n");
         return -1;
     }
-    shm_name_len = strlen(REDS_STAT_SHM_NAME) + strlen(argv[1]);
+    shm_name_len = strlen(SPICE_STAT_SHM_NAME) + strlen(argv[1]);
     if (!(shm_name = (char *)malloc(shm_name_len))) {
         perror("malloc");
         return -1;
     }
-    snprintf(shm_name, shm_name_len, REDS_STAT_SHM_NAME, kvm_pid);
+    snprintf(shm_name, shm_name_len, SPICE_STAT_SHM_NAME, kvm_pid);
     if ((fd = shm_open(shm_name, O_RDONLY, 0444)) == -1) {
         perror("shm_open");
         free(shm_name);
         return -1;
     }
-    shm_size = sizeof(RedsStat);
+    shm_size = sizeof(SpiceStat);
     reds_stat = mmap(NULL, shm_size, PROT_READ, MAP_SHARED, fd, 0);
-    if (reds_stat == (RedsStat *)MAP_FAILED) {
+    if (reds_stat == (SpiceStat *)MAP_FAILED) {
         perror("mmap");
         goto error1;
     }
-    if (reds_stat->magic != REDS_STAT_MAGIC) {
+    if (reds_stat->magic != SPICE_STAT_MAGIC) {
         printf("bad magic %u\n", reds_stat->magic);
         goto error2;
     }
-    if (reds_stat->version != REDS_STAT_VERSION) {
+    if (reds_stat->version != SPICE_STAT_VERSION) {
         printf("bad version %u\n", reds_stat->version);
         goto error2;
     }
@@ -102,9 +102,9 @@ int main(int argc, char **argv)
         if (num_of_nodes != reds_stat->num_of_nodes) {
             num_of_nodes = reds_stat->num_of_nodes;
             shm_old_size = shm_size;
-            shm_size = sizeof(RedsStat) + num_of_nodes * sizeof(StatNode);
+            shm_size = sizeof(SpiceStat) + num_of_nodes * sizeof(SpiceStatNode);
             reds_stat = mremap(reds_stat, shm_old_size, shm_size, MREMAP_MAYMOVE);
-            if (reds_stat == (RedsStat *)MAP_FAILED) {
+            if (reds_stat == (SpiceStat *)MAP_FAILED) {
                 perror("mremap");
                 goto error3;
             }