[PATCH spice-common 2/4] Replace spice_* logging with g_*

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



From: Marc-André Lureau <marcandre.lureau@xxxxxxxxxx>

---
 common/canvas_base.c        | 148 ++++++++++++++++++++---------------------
 common/canvas_utils.c       |  18 ++---
 common/gdi_canvas.c         |  82 +++++++++++------------
 common/lz.c                 |  22 +++----
 common/lz_decompress_tmpl.c |  18 ++---
 common/marshaller.c         |   2 +-
 common/mem.c                |   2 +-
 common/pixman_utils.c       | 156 ++++++++++++++++++++++----------------------
 common/quic.c               |  88 ++++++++++++-------------
 common/quic_family_tmpl.c   |   6 +-
 common/quic_rgb_tmpl.c      |  32 ++++-----
 common/quic_tmpl.c          |  32 ++++-----
 common/rect.h               |   2 +-
 common/region.c             |   2 +-
 common/ring.h               |  26 ++++----
 common/rop3.c               |  10 +--
 common/snd_codec.c          |  18 ++---
 common/ssl_verify.c         |  72 ++++++++++----------
 common/sw_canvas.c          |  20 +++---
 19 files changed, 378 insertions(+), 378 deletions(-)

diff --git a/common/canvas_base.c b/common/canvas_base.c
index 8f653e0..c5cea60 100644
--- a/common/canvas_base.c
+++ b/common/canvas_base.c
@@ -99,7 +99,7 @@ static HDC create_compatible_dc()
 {
     HDC dc = CreateCompatibleDC(NULL);
 
-    spice_return_val_if_fail(dc != NULL, NULL);
+    g_return_val_if_fail(dc != NULL, NULL);
 
     return dc;
 }
@@ -381,7 +381,7 @@ static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceImage *image,
 
     if (setjmp(quic_data->jmp_env)) {
         pixman_image_unref(surface);
-        spice_warning("%s", quic_data->message_buf);
+        g_warning("%s", quic_data->message_buf);
         return NULL;
     }
 
@@ -392,7 +392,7 @@ static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceImage *image,
                           (uint32_t *)image->u.quic.data->chunk[0].data,
                           image->u.quic.data->chunk[0].len >> 2,
                           &type, &width, &height) == QUIC_ERROR) {
-        spice_warning("quic decode begin failed");
+        g_warning("quic decode begin failed");
         return NULL;
     }
 
@@ -420,12 +420,12 @@ static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceImage *image,
     case QUIC_IMAGE_TYPE_INVALID:
     case QUIC_IMAGE_TYPE_GRAY:
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 
-    spice_return_val_if_fail((uint32_t)width == image->descriptor.width, NULL);
-    spice_return_val_if_fail((uint32_t)height == image->descriptor.height, NULL);
+    g_return_val_if_fail((uint32_t)width == image->descriptor.width, NULL);
+    g_return_val_if_fail((uint32_t)height == image->descriptor.height, NULL);
 
     surface = surface_create(
 #ifdef WIN32
@@ -434,14 +434,14 @@ static pixman_image_t *canvas_get_quic(CanvasBase *canvas, SpiceImage *image,
                              pixman_format,
                              width, height, FALSE);
 
-    spice_return_val_if_fail(surface != NULL, NULL);
+    g_return_val_if_fail(surface != NULL, NULL);
 
     dest = (uint8_t *)pixman_image_get_data(surface);
     stride = pixman_image_get_stride(surface);
     if (quic_decode(quic_data->quic, as_type,
                     dest, stride) == QUIC_ERROR) {
         pixman_image_unref(surface);
-        spice_warning("quic decode failed");
+        g_warning("quic decode failed");
         return NULL;
     }
 
@@ -484,11 +484,11 @@ static pixman_image_t *canvas_get_jpeg(CanvasBase *canvas, SpiceImage *image)
     int height;
     uint8_t *dest;
 
-    spice_return_val_if_fail(image->u.jpeg.data->num_chunks == 1, NULL);
+    g_return_val_if_fail(image->u.jpeg.data->num_chunks == 1, NULL);
     canvas->jpeg->ops->begin_decode(canvas->jpeg, image->u.jpeg.data->chunk[0].data, image->u.jpeg.data->chunk[0].len,
                                     &width, &height);
-    spice_return_val_if_fail((uint32_t)width == image->descriptor.width, NULL);
-    spice_return_val_if_fail((uint32_t)height == image->descriptor.height, NULL);
+    g_return_val_if_fail((uint32_t)width == image->descriptor.width, NULL);
+    g_return_val_if_fail((uint32_t)height == image->descriptor.height, NULL);
 
     surface = surface_create(
 #ifdef WIN32
@@ -497,7 +497,7 @@ static pixman_image_t *canvas_get_jpeg(CanvasBase *canvas, SpiceImage *image)
                              PIXMAN_LE_x8r8g8b8,
                              width, height, FALSE);
     if (surface == NULL) {
-        spice_warning("create surface failed");
+        g_warning("create surface failed");
         return NULL;
     }
 
@@ -569,7 +569,7 @@ static pixman_image_t *canvas_get_lz4(CanvasBase *canvas, SpiceImage *image)
             stride_encoded *= 4;
             break;
         default:
-            spice_warning("Unsupported bitmap format %d with LZ4\n", spice_format);
+            g_warning("Unsupported bitmap format %d with LZ4\n", spice_format);
             return NULL;
     }
 
@@ -580,7 +580,7 @@ static pixman_image_t *canvas_get_lz4(CanvasBase *canvas, SpiceImage *image)
                              format,
                              width, height, top_down);
     if (surface == NULL) {
-        spice_warning("create surface failed");
+        g_warning("create surface failed");
         return NULL;
     }
 
@@ -601,7 +601,7 @@ static pixman_image_t *canvas_get_lz4(CanvasBase *canvas, SpiceImage *image)
         dec_size = LZ4_decompress_safe_continue(stream, (const char *) data,
                                                 (char *) dest, enc_size, available);
         if (dec_size <= 0) {
-            spice_warning("Error decoding LZ4 block\n");
+            g_warning("Error decoding LZ4 block\n");
             pixman_image_unref(surface);
             surface = NULL;
             break;
@@ -633,13 +633,13 @@ static pixman_image_t *canvas_get_jpeg_alpha(CanvasBase *canvas, SpiceImage *ima
     int alpha_size;
     int lz_alpha_width, lz_alpha_height, n_comp_pixels, lz_alpha_top_down;
 
-    spice_return_val_if_fail(image->u.jpeg_alpha.data->num_chunks == 1, NULL);
+    g_return_val_if_fail(image->u.jpeg_alpha.data->num_chunks == 1, NULL);
     canvas->jpeg->ops->begin_decode(canvas->jpeg,
                                     image->u.jpeg_alpha.data->chunk[0].data,
                                     image->u.jpeg_alpha.jpeg_size,
                                     &width, &height);
-    spice_return_val_if_fail((uint32_t)width == image->descriptor.width, NULL);
-    spice_return_val_if_fail((uint32_t)height == image->descriptor.height, NULL);
+    g_return_val_if_fail((uint32_t)width == image->descriptor.width, NULL);
+    g_return_val_if_fail((uint32_t)height == image->descriptor.height, NULL);
 
     if (image->u.jpeg_alpha.flags & SPICE_JPEG_ALPHA_FLAGS_TOP_DOWN) {
         alpha_top_down = TRUE;
@@ -652,7 +652,7 @@ static pixman_image_t *canvas_get_jpeg_alpha(CanvasBase *canvas, SpiceImage *ima
                                      width, height, width*height, alpha_top_down);
 
     if (surface == NULL) {
-        spice_warning("create surface failed");
+        g_warning("create surface failed");
         return NULL;
     }
 
@@ -667,11 +667,11 @@ static pixman_image_t *canvas_get_jpeg_alpha(CanvasBase *canvas, SpiceImage *ima
     lz_decode_begin(lz_data->lz, comp_alpha_buf, alpha_size, &lz_alpha_type,
                     &lz_alpha_width, &lz_alpha_height, &n_comp_pixels,
                     &lz_alpha_top_down, NULL);
-    spice_return_val_if_fail(lz_alpha_type == LZ_IMAGE_TYPE_XXXA, NULL);
-    spice_return_val_if_fail(!!lz_alpha_top_down == !!alpha_top_down, NULL);
-    spice_return_val_if_fail(lz_alpha_width == width, NULL);
-    spice_return_val_if_fail(lz_alpha_height == height, NULL);
-    spice_return_val_if_fail(n_comp_pixels == width * height, NULL);
+    g_return_val_if_fail(lz_alpha_type == LZ_IMAGE_TYPE_XXXA, NULL);
+    g_return_val_if_fail(!!lz_alpha_top_down == !!alpha_top_down, NULL);
+    g_return_val_if_fail(lz_alpha_width == width, NULL);
+    g_return_val_if_fail(lz_alpha_height == height, NULL);
+    g_return_val_if_fail(n_comp_pixels == width * height, NULL);
 
     if (!alpha_top_down) {
         decomp_alpha_buf = dest + stride * (height - 1);
@@ -711,7 +711,7 @@ static pixman_image_t *canvas_bitmap_to_surface(CanvasBase *canvas, SpiceBitmap*
                            format,
                            bitmap->x, bitmap->y, FALSE);
     if (image == NULL) {
-        spice_warning("create surface failed");
+        g_warning("create surface failed");
         return NULL;
     }
 
@@ -772,7 +772,7 @@ static inline SpicePalette *canvas_get_localized_palette(CanvasBase *canvas, Spi
         break;
     case SPICE_SURFACE_FMT_16_565:
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         free(copy);
         return NULL;
     }
@@ -800,23 +800,23 @@ static pixman_image_t *canvas_get_lz(CanvasBase *canvas, SpiceImage *image,
 
     if (setjmp(lz_data->jmp_env)) {
         free(decomp_buf);
-        spice_warning("%s", lz_data->message_buf);
+        g_warning("%s", lz_data->message_buf);
         return NULL;
     }
 
     free_palette = FALSE;
     if (image->descriptor.type == SPICE_IMAGE_TYPE_LZ_RGB) {
-        spice_return_val_if_fail(image->u.lz_rgb.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
+        g_return_val_if_fail(image->u.lz_rgb.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
         comp_buf = image->u.lz_rgb.data->chunk[0].data;
         comp_size = image->u.lz_rgb.data->chunk[0].len;
         palette = NULL;
     } else if (image->descriptor.type == SPICE_IMAGE_TYPE_LZ_PLT) {
-        spice_return_val_if_fail(image->u.lz_plt.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
+        g_return_val_if_fail(image->u.lz_plt.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
         comp_buf = image->u.lz_plt.data->chunk[0].data;
         comp_size = image->u.lz_plt.data->chunk[0].len;
         palette = canvas_get_localized_palette(canvas, image->u.lz_plt.palette, image->u.lz_plt.palette_id, image->u.lz_plt.flags, &free_palette);
     } else {
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 
@@ -859,14 +859,14 @@ static pixman_image_t *canvas_get_lz(CanvasBase *canvas, SpiceImage *image,
         }
         break;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 
-    spice_return_val_if_fail((unsigned)width == image->descriptor.width, NULL);
-    spice_return_val_if_fail((unsigned)height == image->descriptor.height, NULL);
+    g_return_val_if_fail((unsigned)width == image->descriptor.width, NULL);
+    g_return_val_if_fail((unsigned)height == image->descriptor.height, NULL);
 
-    spice_return_val_if_fail((image->descriptor.type == SPICE_IMAGE_TYPE_LZ_PLT) || (n_comp_pixels == width * height), NULL);
+    g_return_val_if_fail((image->descriptor.type == SPICE_IMAGE_TYPE_LZ_PLT) || (n_comp_pixels == width * height), NULL);
 #ifdef WIN32
     lz_data->decode_data.dc = canvas->dc;
 #endif
@@ -897,7 +897,7 @@ static pixman_image_t *canvas_get_lz(CanvasBase *canvas, SpiceImage *image,
 static pixman_image_t *canvas_get_glz_rgb_common(CanvasBase *canvas, uint8_t *data,
                                                  int want_original)
 {
-    spice_return_val_if_fail(canvas->glz_data.decoder != NULL, NULL);
+    g_return_val_if_fail(canvas->glz_data.decoder != NULL, NULL);
 
     canvas->glz_data.decoder->ops->decode(canvas->glz_data.decoder,
                                           data, NULL,
@@ -912,12 +912,12 @@ static pixman_image_t *canvas_get_glz_rgb_common(CanvasBase *canvas, uint8_t *da
 static pixman_image_t *canvas_get_glz(CanvasBase *canvas, SpiceImage *image,
                                       int want_original)
 {
-    spice_return_val_if_fail(image->descriptor.type == SPICE_IMAGE_TYPE_GLZ_RGB, NULL);
+    g_return_val_if_fail(image->descriptor.type == SPICE_IMAGE_TYPE_GLZ_RGB, NULL);
 #ifdef WIN32
     canvas->glz_data.decode_data.dc = canvas->dc;
 #endif
 
-    spice_return_val_if_fail(image->u.lz_rgb.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
+    g_return_val_if_fail(image->u.lz_rgb.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
     return canvas_get_glz_rgb_common(canvas, image->u.lz_rgb.data->chunk[0].data, want_original);
 }
 
@@ -927,9 +927,9 @@ static pixman_image_t *canvas_get_zlib_glz_rgb(CanvasBase *canvas, SpiceImage *i
     uint8_t *glz_data;
     pixman_image_t *surface;
 
-    spice_return_val_if_fail(canvas->zlib != NULL, NULL);
+    g_return_val_if_fail(canvas->zlib != NULL, NULL);
 
-    spice_return_val_if_fail(image->u.zlib_glz.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
+    g_return_val_if_fail(image->u.zlib_glz.data->num_chunks == 1, NULL); /* TODO: Handle chunks */
     glz_data = (uint8_t*)spice_malloc(image->u.zlib_glz.glz_data_size);
     canvas->zlib->ops->decode(canvas->zlib, image->u.zlib_glz.data->chunk[0].data,
                               image->u.zlib_glz.data->chunk[0].len,
@@ -1142,7 +1142,7 @@ static pixman_image_t *get_surface_from_canvas(CanvasBase *canvas,
 #ifdef USE_LZ4
         return canvas_get_lz4(canvas, image);
 #else
-        spice_warning("Lz4 compression algorithm not supported.\n");
+        g_warning("Lz4 compression algorithm not supported.\n");
         return NULL;
 #endif
 
@@ -1154,7 +1154,7 @@ static pixman_image_t *get_surface_from_canvas(CanvasBase *canvas,
         return canvas_get_bits(canvas, &image->u.bitmap, want_original);
 
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 }
@@ -1200,8 +1200,8 @@ static pixman_image_t *canvas_get_image_internal(CanvasBase *canvas, SpiceImage
 
     surface = get_surface_from_canvas(canvas, image, want_original);
 
-    spice_return_val_if_fail(surface != NULL, NULL);
-    spice_return_val_if_fail(spice_pixman_image_get_format(surface, &surface_format), NULL);
+    g_return_val_if_fail(surface != NULL, NULL);
+    g_return_val_if_fail(spice_pixman_image_get_format(surface, &surface_format), NULL);
 
     if (descriptor->flags & SPICE_IMAGE_FLAGS_HIGH_BITS_SET &&
         descriptor->type != SPICE_IMAGE_TYPE_FROM_CACHE &&
@@ -1236,7 +1236,7 @@ static pixman_image_t *canvas_get_image_internal(CanvasBase *canvas, SpiceImage
 #ifdef SW_CANVAS_CACHE
     } else if (descriptor->flags & SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME) {
         if (spice_image_descriptor_is_lossy(descriptor)) {
-            spice_warning("invalid cache replace request: the image is lossy");
+            g_warning("invalid cache replace request: the image is lossy");
             return NULL;
         }
         canvas->bits_cache->ops->replace_lossy(canvas->bits_cache, descriptor->id, surface);
@@ -1335,13 +1335,13 @@ static pixman_image_t* canvas_get_image_from_self(SpiceCanvas *canvas,
         /* Set alpha bits of the format to 0 */
         format = (pixman_format_code_t)(((uint32_t)format) & ~(0xf << 12));
 
-        spice_return_val_if_fail (
+        g_return_val_if_fail (
             pixman_format_supported_destination (format), NULL);
     }
 
     surface = pixman_image_create_bits(spice_surface_format_to_pixman (canvas_base->format),
                                        width, height, NULL, 0);
-    spice_return_val_if_fail(surface != NULL, NULL);
+    g_return_val_if_fail(surface != NULL, NULL);
 
     dest = (uint8_t *)pixman_image_get_data(surface);
     dest_stride = pixman_image_get_stride(surface);
@@ -1427,7 +1427,7 @@ static pixman_image_t *canvas_get_bitmap_mask(CanvasBase *canvas, SpiceBitmap* b
             canvas->dc,
 #endif
             PIXMAN_a1, bitmap->x, bitmap->y, TRUE);
-    spice_return_val_if_fail(surface != NULL, NULL);
+    g_return_val_if_fail(surface != NULL, NULL);
 
     spice_chunks_linearize(bitmap->data);
     src_line = bitmap->data->chunk[0].data;
@@ -1438,7 +1438,7 @@ static pixman_image_t *canvas_get_bitmap_mask(CanvasBase *canvas, SpiceBitmap* b
     dest_stride = pixman_image_get_stride(surface);
     dest_line = (uint8_t *)pixman_image_get_data(surface);
     if (!(bitmap->flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
-        spice_return_val_if_fail(bitmap->y > 0, NULL);
+        g_return_val_if_fail(bitmap->y > 0, NULL);
         dest_line += dest_stride * ((int)bitmap->y - 1);
         dest_stride = -dest_stride;
     }
@@ -1477,7 +1477,7 @@ static pixman_image_t *canvas_get_bitmap_mask(CanvasBase *canvas, SpiceBitmap* b
         default:
             pixman_image_unref(surface);
             surface = NULL;
-            spice_warn_if_reached();
+            g_warn_if_reached();
             return NULL;
         }
     } else {
@@ -1509,7 +1509,7 @@ static pixman_image_t *canvas_get_bitmap_mask(CanvasBase *canvas, SpiceBitmap* b
         default:
             pixman_image_unref(surface);
             surface = NULL;
-            spice_warn_if_reached();
+            g_warn_if_reached();
             return NULL;
         }
     }
@@ -1524,10 +1524,10 @@ static inline pixman_image_t *canvas_A1_invers(pixman_image_t *src_surf)
     uint8_t *src_line, *end_line,  *dest_line;
     int src_stride, line_size, dest_stride;
 
-    spice_return_val_if_fail(pixman_image_get_depth(src_surf) == 1, NULL);
+    g_return_val_if_fail(pixman_image_get_depth(src_surf) == 1, NULL);
 
     invers = pixman_image_create_bits(PIXMAN_a1, width, height, NULL, 0);
-    spice_return_val_if_fail(invers != NULL, NULL);
+    g_return_val_if_fail(invers != NULL, NULL);
 
     src_line = (uint8_t *)pixman_image_get_data(src_surf);
     src_stride = pixman_image_get_stride(src_surf);
@@ -1585,7 +1585,7 @@ static pixman_image_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask, int
         break;
 #endif
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 
@@ -1609,7 +1609,7 @@ static pixman_image_t *canvas_get_mask(CanvasBase *canvas, SpiceQMask *mask, int
 
 static inline void canvas_raster_glyph_box(const SpiceRasterGlyph *glyph, SpiceRect *r)
 {
-    spice_return_if_fail(r != NULL);
+    g_return_if_fail(r != NULL);
 
     r->top = glyph->render_pos.y + glyph->glyph_origin.y;
     r->bottom = r->top + glyph->height;
@@ -1661,8 +1661,8 @@ static void canvas_put_glyph_bits(SpiceRasterGlyph *glyph, int bpp, uint8_t *des
 
     //todo: support SPICE_STRING_FLAGS_RASTER_TOP_DOWN
     canvas_raster_glyph_box(glyph, &glyph_box);
-    spice_return_if_fail(glyph_box.top >= bounds->top && glyph_box.bottom <= bounds->bottom);
-    spice_return_if_fail(glyph_box.left >= bounds->left && glyph_box.right <= bounds->right);
+    g_return_if_fail(glyph_box.top >= bounds->top && glyph_box.bottom <= bounds->bottom);
+    g_return_if_fail(glyph_box.left >= bounds->left && glyph_box.right <= bounds->right);
     rect_offset(&glyph_box, -bounds->left, -bounds->top);
 
     dest += glyph_box.top * dest_stride;
@@ -1723,7 +1723,7 @@ static void canvas_put_glyph_bits(SpiceRasterGlyph *glyph, int bpp, uint8_t *des
         break;
     }
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return;
     }
 }
@@ -1737,7 +1737,7 @@ static pixman_image_t *canvas_get_str_mask(CanvasBase *canvas, SpiceString *str,
     int dest_stride;
     int i;
 
-    spice_return_val_if_fail(str->length > 0, NULL);
+    g_return_val_if_fail(str->length > 0, NULL);
 
     glyph = str->glyphs[0];
     canvas_raster_glyph_box(glyph, &bounds);
@@ -1752,7 +1752,7 @@ static pixman_image_t *canvas_get_str_mask(CanvasBase *canvas, SpiceString *str,
     str_mask = pixman_image_create_bits((bpp == 1) ? PIXMAN_a1 : PIXMAN_a8,
                                         bounds.right - bounds.left,
                                         bounds.bottom - bounds.top, NULL, 0);
-    spice_return_val_if_fail(str_mask != NULL, NULL);
+    g_return_val_if_fail(str_mask != NULL, NULL);
 
     dest = (uint8_t *)pixman_image_get_data(str_mask);
     dest_stride = pixman_image_get_stride(str_mask);
@@ -1774,10 +1774,10 @@ static pixman_image_t *canvas_scale_surface(pixman_image_t *src, const SpiceRect
     pixman_format_code_t format;
     double sx, sy;
 
-    spice_return_val_if_fail(spice_pixman_image_get_format (src, &format), NULL);
+    g_return_val_if_fail(spice_pixman_image_get_format (src, &format), NULL);
 
     surface = pixman_image_create_bits(format, width, height, NULL, 0);
-    spice_return_val_if_fail(surface != NULL, NULL);
+    g_return_val_if_fail(surface != NULL, NULL);
 
     sx = (double)(src_area->right - src_area->left) / width;
     sy = (double)(src_area->bottom - src_area->top) / height;
@@ -1786,7 +1786,7 @@ static pixman_image_t *canvas_scale_surface(pixman_image_t *src, const SpiceRect
 
     pixman_image_set_transform (src, &transform);
     pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
-    spice_return_val_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE || scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST, NULL);
+    g_return_val_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE || scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST, NULL);
     pixman_image_set_filter(src,
                             (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?PIXMAN_FILTER_NEAREST : PIXMAN_FILTER_GOOD,
                             NULL, 0);
@@ -1931,7 +1931,7 @@ static void canvas_clip_pixman(CanvasBase *canvas,
         break;
     }
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return;
     }
 }
@@ -2080,7 +2080,7 @@ static void draw_brush(SpiceCanvas *canvas,
             }
         } else {
             tile = canvas_get_image(canvas_base, pattern->pat, FALSE);
-            spice_return_if_fail(tile != NULL);
+            g_return_if_fail(tile != NULL);
 
             if (rop == SPICE_ROP_COPY) {
                 canvas->ops->fill_tiled_rects(canvas, rects, n_rects, tile, offset_x, offset_y);
@@ -2097,7 +2097,7 @@ static void draw_brush(SpiceCanvas *canvas,
         canvas->ops->fill_solid_rects_rop(canvas, rects, n_rects, 0, rop);
         break;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return;
     }
 }
@@ -2217,7 +2217,7 @@ static void canvas_draw_copy(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceCl
         }
     } else {
         src_image = canvas_get_image(canvas, copy->src_bitmap, FALSE);
-        spice_return_if_fail(src_image != NULL);
+        g_return_if_fail(src_image != NULL);
 
         if (rect_is_same_size(bbox, &copy->src_area)) {
             if (rop == SPICE_ROP_COPY) {
@@ -2324,7 +2324,7 @@ static void canvas_draw_transparent(SpiceCanvas *spice_canvas, SpiceRect *bbox,
         }
     } else {
         src_image = canvas_get_image(canvas, transparent->src_bitmap, FALSE);
-        spice_return_if_fail(src_image != NULL);
+        g_return_if_fail(src_image != NULL);
 
         if (rect_is_same_size(bbox, &transparent->src_area)) {
             spice_canvas->ops->colorkey_image(spice_canvas, &dest_region,
@@ -2403,7 +2403,7 @@ static void canvas_draw_alpha_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox,
         }
      } else {
         src_image = canvas_get_image(canvas, alpha_blend->src_bitmap, TRUE);
-        spice_return_if_fail(src_image != NULL);
+        g_return_if_fail(src_image != NULL);
 
         if (rect_is_same_size(bbox, &alpha_blend->src_area)) {
             spice_canvas->ops->blend_image(spice_canvas, &dest_region,
@@ -2488,7 +2488,7 @@ static void canvas_draw_opaque(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spice
         }
     } else {
         src_image = canvas_get_image(canvas, opaque->src_bitmap, FALSE);
-        spice_return_if_fail(src_image != NULL);
+        g_return_if_fail(src_image != NULL);
 
         if (rect_is_same_size(bbox, &opaque->src_area)) {
             spice_canvas->ops->blit_image(spice_canvas, &dest_region,
@@ -2586,7 +2586,7 @@ static void canvas_draw_blend(SpiceCanvas *spice_canvas, SpiceRect *bbox, SpiceC
         }
     } else {
         src_image = canvas_get_image(canvas, blend->src_bitmap, FALSE);
-        spice_return_if_fail(src_image != NULL);
+        g_return_if_fail(src_image != NULL);
 
         if (rect_is_same_size(bbox, &blend->src_area)) {
             if (rop == SPICE_ROP_COPY)
@@ -3131,7 +3131,7 @@ static void canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox,
         gc.tile_offset_y = stroke->brush.u.pattern.pos.y;
         break;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return;
     }
 
@@ -3151,7 +3151,7 @@ static void canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox,
         }
 
         if (seg->flags & SPICE_PATH_BEZIER) {
-            spice_return_if_fail((point - end_point) % 3 == 0);
+            g_return_if_fail((point - end_point) % 3 == 0);
             for (; point + 2 < end_point; point += 3) {
                 stroke_lines_append_bezier(&lines,
                                            &point[0],
@@ -3232,7 +3232,7 @@ static void canvas_draw_rop3(SpiceCanvas *spice_canvas, SpiceRect *bbox,
     }
     if (pixman_image_get_width(s) - src_pos.x < width ||
         pixman_image_get_height(s) - src_pos.y < heigth) {
-        spice_critical("bad src bitmap size");
+        g_critical("bad src bitmap size");
         return;
     }
     if (rop3->brush.type == SPICE_BRUSH_TYPE_PATTERN) {
@@ -3438,7 +3438,7 @@ static void canvas_base_group_end(SpiceCanvas *spice_canvas)
 
 static void unimplemented_op(SpiceCanvas *canvas)
 {
-    spice_critical("unimplemented canvas operation");
+    g_critical("unimplemented canvas operation");
 }
 
 inline static void canvas_base_init_ops(SpiceCanvasOps *ops)
diff --git a/common/canvas_utils.c b/common/canvas_utils.c
index 0be761a..c0ff7eb 100644
--- a/common/canvas_utils.c
+++ b/common/canvas_utils.c
@@ -53,7 +53,7 @@ pixman_image_add_data(pixman_image_t *image)
     if (data == NULL) {
         data = (PixmanData *)calloc(1, sizeof(PixmanData));
         if (data == NULL) {
-            spice_error("out of memory");
+            g_error("out of memory");
         }
         pixman_image_set_destroy_function(image,
                                           release_data,
@@ -78,7 +78,7 @@ int spice_pixman_image_get_format(pixman_image_t *image, pixman_format_code_t *f
 {
     PixmanData *data;
 
-    spice_return_val_if_fail(format != NULL, 0);
+    g_return_val_if_fail(format != NULL, 0);
 
     data = (PixmanData *)pixman_image_get_destroy_data(image);
     if (data != NULL && data->format != 0) {
@@ -86,7 +86,7 @@ int spice_pixman_image_get_format(pixman_image_t *image, pixman_format_code_t *f
         return 1;
     }
 
-    spice_warn_if_reached();
+    g_warn_if_reached();
     return 0;
 }
 
@@ -110,7 +110,7 @@ static inline pixman_image_t *__surface_create_stride(pixman_format_code_t forma
     if (surface == NULL) {
         free(data);
         data = NULL;
-        spice_error("create surface failed, out of memory");
+        g_error("create surface failed, out of memory");
     }
 
     pixman_data = pixman_image_add_data(surface);
@@ -186,7 +186,7 @@ pixman_image_t * surface_create(pixman_format_code_t format, int width, int heig
             nstride = SPICE_ALIGN(width, 32) / 8;
             break;
         default:
-            spice_error("invalid format");
+            g_error("invalid format");
             return NULL;
         }
 
@@ -194,13 +194,13 @@ pixman_image_t * surface_create(pixman_format_code_t format, int width, int heig
 
         mutex = CreateMutex(NULL, 0, NULL);
         if (!mutex) {
-            spice_error("Unable to CreateMutex");
+            g_error("Unable to CreateMutex");
         }
 
         bitmap = CreateDIBSection(dc, &bitmap_info.inf, 0, (VOID **)&data, NULL, 0);
         if (!bitmap) {
             CloseHandle(mutex);
-            spice_error("Unable to CreateDIBSection");
+            g_error("Unable to CreateDIBSection");
         }
 
         if (top_down) {
@@ -214,7 +214,7 @@ pixman_image_t * surface_create(pixman_format_code_t format, int width, int heig
         if (surface == NULL) {
             CloseHandle(mutex);
             DeleteObject(bitmap);
-            spice_error("create surface failed, out of memory");
+            g_error("create surface failed, out of memory");
         }
         pixman_data = pixman_image_add_data(surface);
         pixman_data->format = format;
@@ -262,7 +262,7 @@ pixman_image_t * surface_create(pixman_format_code_t format, int width, int heig
             stride = SPICE_ALIGN(width, 32) / 8;
             break;
         default:
-            spice_error("invalid format");
+            g_error("invalid format");
         }
         stride = -stride;
         return __surface_create_stride(format, width, height, stride);
diff --git a/common/gdi_canvas.c b/common/gdi_canvas.c
index fcc5fc9..3e50df2 100644
--- a/common/gdi_canvas.c
+++ b/common/gdi_canvas.c
@@ -327,14 +327,14 @@ static void set_path(GdiCanvas *canvas, SpicePath *s)
             BeginPath(canvas->dc);
             if (!MoveToEx(canvas->dc, (int)fix_to_double(point->x), (int)fix_to_double(point->y),
                           NULL)) {
-                spice_critical("MoveToEx failed");
+                g_critical("MoveToEx failed");
                 return;
             }
             point++;
         }
 
         if (seg->flags & SPICE_PATH_BEZIER) {
-            spice_return_if_fail((point - end_point) % 3 == 0);
+            g_return_if_fail((point - end_point) % 3 == 0);
             for (; point + 2 < end_point; point += 3) {
                 POINT points[3];
 
@@ -345,7 +345,7 @@ static void set_path(GdiCanvas *canvas, SpicePath *s)
                 points[2].x = (int)fix_to_double(point[2].x);
                 points[2].y = (int)fix_to_double(point[2].y);
                 if (!PolyBezierTo(canvas->dc, points, 3)) {
-                    spice_critical("PolyBezierTo failed");
+                    g_critical("PolyBezierTo failed");
                     return;
                 }
             }
@@ -353,7 +353,7 @@ static void set_path(GdiCanvas *canvas, SpicePath *s)
             for (; point < end_point; point++) {
                 if (!LineTo(canvas->dc, (int)fix_to_double(point->x),
                             (int)fix_to_double(point->y))) {
-                    spice_critical("LineTo failed");
+                    g_critical("LineTo failed");
                 }
             }
         }
@@ -362,12 +362,12 @@ static void set_path(GdiCanvas *canvas, SpicePath *s)
 
             if (seg->flags & SPICE_PATH_CLOSE) {
                 if (!CloseFigure(canvas->dc)) {
-                    spice_critical("CloseFigure failed");
+                    g_critical("CloseFigure failed");
                 }
             }
 
             if (!EndPath(canvas->dc)) {
-                spice_critical("EndPath failed");
+                g_critical("EndPath failed");
             }
         }
 
@@ -381,7 +381,7 @@ static void set_scale_mode(GdiCanvas *canvas, uint8_t scale_mode)
     } else if (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) {
         SetStretchBltMode(canvas->dc, COLORONCOLOR);
     } else {
-        spice_critical("Unknown ScaleMode");
+        g_critical("Unknown ScaleMode");
     }
 }
 
@@ -390,7 +390,7 @@ static void set_clip(GdiCanvas *canvas, SpiceClip *clip)
     switch (clip->type) {
     case SPICE_CLIP_TYPE_NONE:
         if (SelectClipRgn(canvas->dc, NULL) == ERROR) {
-            spice_critical("SelectClipRgn failed");
+            g_critical("SelectClipRgn failed");
         }
         break;
     case SPICE_CLIP_TYPE_RECTS: {
@@ -412,26 +412,26 @@ static void set_clip(GdiCanvas *canvas, SpiceClip *clip)
                 combaine_hrgn = CreateRectRgn(now->left, now->top, now->right,
                                               now->bottom);
                 if (!combaine_hrgn) {
-                    spice_critical("Unable to CreateRectRgn");
+                    g_critical("Unable to CreateRectRgn");
                     DeleteObject(main_hrgn);
                     return;
                 }
                 if (CombineRgn(main_hrgn, main_hrgn, combaine_hrgn, RGN_OR) == ERROR) {
-                    spice_critical("Unable to CombineRgn");
+                    g_critical("Unable to CombineRgn");
                     DeleteObject(combaine_hrgn);
                     return;
                 }
                 DeleteObject(combaine_hrgn);
             }
             if (SelectClipRgn(canvas->dc, main_hrgn) == ERROR) {
-                spice_critical("Unable to SelectClipRgn");
+                g_critical("Unable to SelectClipRgn");
             }
             DeleteObject(main_hrgn);
         }
         break;
     }
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return;
     }
 }
@@ -442,7 +442,7 @@ static void copy_bitmap(const uint8_t *src_image, int height, int src_stride,
     int copy_width = MIN(dest_stride, src_stride);
     int y = 0;
 
-    spice_return_if_fail(dest_stride >= 0 && src_stride >= 0);
+    g_return_if_fail(dest_stride >= 0 && src_stride >= 0);
 
     while (y < height) {
         memcpy(dest_bitmap, src_image, copy_width);
@@ -531,13 +531,13 @@ static uint8_t *create_bitmap(HBITMAP *bitmap, HBITMAP *prev_bitmap, HDC *dc,
 
     *dc = create_compatible_dc();
     if (!*dc) {
-        spice_critical("create_compatible_dc() failed");
+        g_critical("create_compatible_dc() failed");
         return NULL;
     }
 
     *bitmap = CreateDIBSection(*dc, &bitmap_info.inf, 0, (VOID **)&data, NULL, 0);
     if (!*bitmap) {
-        spice_critical("Unable to CreateDIBSection");
+        g_critical("Unable to CreateDIBSection");
         DeleteDC(*dc);
         return NULL;
     }
@@ -563,7 +563,7 @@ static uint8_t *create_bitmap(HBITMAP *bitmap, HBITMAP *prev_bitmap, HDC *dc,
         nstride = width * 4;
         break;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 
@@ -637,7 +637,7 @@ static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush, RecurciveMutex **b
     switch (brush->type) {
     case SPICE_BRUSH_TYPE_SOLID:
         if (!(hbrush = CreateSolidBrush(get_color_ref(canvas, brush->u.color)))) {
-            spice_critical("CreateSolidBrush failed");
+            g_critical("CreateSolidBrush failed");
             return NULL;
         }
         return hbrush;
@@ -653,20 +653,20 @@ static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush, RecurciveMutex **b
         if (gdi_surface) {
             bitmap = (HBITMAP)GetCurrentObject(gdi_surface->dc, OBJ_BITMAP);
             if (!bitmap) {
-                spice_critical("GetCurrentObject failed");
+                g_critical("GetCurrentObject failed");
                 return NULL;
             }
             *brush_lock = gdi_surface->lock;
         } else {
             surface = canvas_get_image(&canvas->base, brush->u.pattern.pat, FALSE);
             if (!create_bitmap_from_pixman(&bitmap, &prev_bitmap, &dc, surface, 0)) {
-                spice_critical("create_bitmap failed");
+                g_critical("create_bitmap failed");
                 return NULL;
             }
         }
 
         if (!(hbrush = CreatePatternBrush(bitmap))) {
-            spice_critical("CreatePatternBrush failed");
+            g_critical("CreatePatternBrush failed");
             return NULL;
         }
 
@@ -679,7 +679,7 @@ static HBRUSH get_brush(GdiCanvas *canvas, SpiceBrush *brush, RecurciveMutex **b
     case SPICE_BRUSH_TYPE_NONE:
         return NULL;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 }
@@ -694,13 +694,13 @@ static HBRUSH set_brush(HDC dc, HBRUSH hbrush, SpiceBrush *brush)
         HBRUSH prev_hbrush;
         prev_hbrush = (HBRUSH)SelectObject(dc, hbrush);
         if (!SetBrushOrgEx(dc, brush->u.pattern.pos.x, brush->u.pattern.pos.y, NULL)) {
-            spice_critical("SetBrushOrgEx failed");
+            g_critical("SetBrushOrgEx failed");
             return NULL;
         }
         return prev_hbrush;
     }
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
 }
@@ -756,7 +756,7 @@ uint8_t calc_rop3(uint16_t rop3_bits, int brush)
 
     if (rop3_bits & SPICE_ROPD_OP_BLACKNESS || rop3_bits & SPICE_ROPD_OP_WHITENESS ||
         rop3_bits & SPICE_ROPD_OP_INVERS) {
-        spice_warning("invalid rop3 type");
+        g_warning("invalid rop3 type");
         return 0;
     }
     return rop3;
@@ -806,7 +806,7 @@ static struct BitmapData get_mask_bitmap(struct GdiCanvas *canvas, struct SpiceQ
 
         _bitmap = (HBITMAP)GetCurrentObject(gdi_surface->dc, OBJ_BITMAP);
         if (!_bitmap) {
-            spice_critical("GetCurrentObject failed");
+            g_critical("GetCurrentObject failed");
             return bitmap;
         }
         bitmap.dc = gdi_surface->dc;
@@ -855,14 +855,14 @@ static void gdi_draw_bitmap(HDC dest_dc, const SpiceRect *src, const SpiceRect *
                                            (dest->bottom - dest->top) == (src->bottom - src->top)) {
             if (!BitBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
                         dest->bottom - dest->top, src_dc, src->left, src->top, rast_oper)) {
-                spice_critical("BitBlt failed");
+                g_critical("BitBlt failed");
                 return;
             }
         } else {
             if (!StretchBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
                             dest->bottom - dest->top, src_dc, src->left, src->top,
                             src->right - src->left, src->bottom - src->top, rast_oper)) {
-                spice_critical("StretchBlt failed");
+                g_critical("StretchBlt failed");
                 return;
             }
         }
@@ -873,7 +873,7 @@ static void gdi_draw_bitmap(HDC dest_dc, const SpiceRect *src, const SpiceRect *
                      dest->bottom - dest->top, src_dc, src->left, src->top,
                      bitmapmask->hbitmap, bitmapmask->pos.x, bitmapmask->pos.y,
                      rast_oper)) {
-            spice_critical("MaskBlt failed");
+            g_critical("MaskBlt failed");
             return;
         }
     }
@@ -913,7 +913,7 @@ static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
 
     bitmap.hbitmap = (HBITMAP)1;
     if (!(surface = canvas_get_str_mask(&canvas->base, str, n, &pos))) {
-        spice_critical("unable to canvas_get_str_mask");
+        g_critical("unable to canvas_get_str_mask");
         return;
     }
 
@@ -954,7 +954,7 @@ static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
         dest_stride = dest_stride * 4;
         break;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return;
     }
     dest_stride = dest_stride + 3;
@@ -1028,7 +1028,7 @@ static void gdi_canvas_draw_fill(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
     RecurciveLock lock(*canvas->lock);
 
     brush = get_brush(canvas, &fill->brush, &brush_lock);
-    spice_return_if_fail(brush != NULL);
+    g_return_if_fail(brush != NULL);
 
     bitmapmask = get_mask_bitmap(canvas, &fill->mask);
 
@@ -1130,18 +1130,18 @@ static void gdi_canvas_put_image(SpiceCanvas *spice_canvas, HDC dc, const SpiceR
                                               rects[i].x2,
                                               rects[i].y2);
                 if (!combaine_hrgn) {
-                    spice_critical("CreateRectRgn failed");
+                    g_critical("CreateRectRgn failed");
                     DeleteObject(main_hrgn);
                     return;
                 }
                 if (!CombineRgn(main_hrgn, main_hrgn, combaine_hrgn, RGN_OR)) {
-                    spice_critical("CombineRgn failed in put_image");
+                    g_critical("CombineRgn failed in put_image");
                     return;
                 }
                 DeleteObject(combaine_hrgn);
             }
             if (SelectClipRgn(canvas->dc, main_hrgn) == ERROR) {
-                spice_critical("SelectClipRgn failed in put_image");
+                g_critical("SelectClipRgn failed in put_image");
                 DeleteObject(main_hrgn);
                 return;
             }
@@ -1245,7 +1245,7 @@ static void gdi_draw_bitmap_alpha(HDC dest_dc, const SpiceRect *src, const Spice
     if (!AlphaBlend(dest_dc, dest->left, dest->top, dest->right - dest->left,
                     dest->bottom - dest->top, src_dc, src->left, src->top,
                     src->right - src->left, src->bottom - src->top, bf)) {
-        spice_critical("AlphaBlend failed");
+        g_critical("AlphaBlend failed");
         return;
     }
 }
@@ -1590,7 +1590,7 @@ static void gdi_canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
 
         draw_str_mask_bitmap(canvas, str, 4, &dest, &src, &text->fore_brush);
     } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
-        spice_warning("untested path A8 glyphs, doing nothing");
+        g_warning("untested path A8 glyphs, doing nothing");
         if (0) {
             SpiceRect dest;
             SpiceRect src;
@@ -1598,7 +1598,7 @@ static void gdi_canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox, Spi
             draw_str_mask_bitmap(canvas, str, 8, &dest, &src, &text->fore_brush);
         }
     } else {
-        spice_warning("untested path vector glyphs, doing nothing");
+        g_warning("untested path vector glyphs, doing nothing");
         if (0) {
         }
     }
@@ -1609,7 +1609,7 @@ static uint32_t *gdi_get_userstyle(GdiCanvas *canvas, uint8_t nseg, SPICE_FIXED2
     uint32_t *local_style;
     int i;
 
-    spice_return_val_if_fail(nseg != 0, NULL);
+    g_return_val_if_fail(nseg != 0, NULL);
 
     local_style = spice_new(uint32_t , nseg);
 
@@ -1709,7 +1709,7 @@ static void gdi_canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
         GdiImage image;
 #endif
 #if 0
-        spice_return_if_fail(surface != NULL)
+        g_return_if_fail(surface != NULL)
         surface_to_image(surface, &image);
 
         memset(&bitmap_info, 0, sizeof(bitmap_info));
@@ -1728,7 +1728,7 @@ static void gdi_canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
             logbrush.lbHatch = (LONG)GlobalAlloc(GMEM_MOVEABLE,
                                                  image.height * -image.stride + sizeof(BITMAPINFO));
             if (!logbrush.lbHatch) {
-                spice_critical("GlobalAlloc failed");
+                g_critical("GlobalAlloc failed");
                 return;
             }
             copy_bitmap(image.pixels - (image.height - 1) * -image.stride,
@@ -1738,7 +1738,7 @@ static void gdi_canvas_draw_stroke(SpiceCanvas *spice_canvas, SpiceRect *bbox, S
             logbrush.lbHatch = (LONG)GlobalAlloc(GMEM_MOVEABLE,
                                                  image.height * image.stride + sizeof(BITMAPINFO));
             if (!logbrush.lbHatch) {
-                spice_critical("GlobalAlloc failed");
+                g_critical("GlobalAlloc failed");
                 return;
             }
             copy_bitmap(image.pixels, image.height, image.stride,
diff --git a/common/lz.c b/common/lz.c
index 2589223..a20ccbb 100644
--- a/common/lz.c
+++ b/common/lz.c
@@ -172,7 +172,7 @@ static int lz_read_image_segments(Encoder *encoder, uint8_t *first_lines,
     uint8_t* lines = first_lines;
     int row;
 
-    spice_return_val_if_fail(!encoder->head_image_segs, FALSE);
+    g_return_val_if_fail(!encoder->head_image_segs, FALSE);
 
     image_seg = lz_alloc_image_seg(encoder);
     if (!image_seg) {
@@ -228,10 +228,10 @@ static inline void encode(Encoder *encoder, uint8_t byte)
         if (more_io_bytes(encoder) <= 0) {
             encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
         }
-        spice_return_if_fail(encoder->io_now);
+        g_return_if_fail(encoder->io_now);
     }
 
-    spice_return_if_fail(encoder->io_now < encoder->io_end);
+    g_return_if_fail(encoder->io_now < encoder->io_end);
     *(encoder->io_now++) = byte;
 }
 
@@ -251,7 +251,7 @@ static inline void encode_copy_count(Encoder *encoder, uint8_t copy_count)
 
 static inline void update_copy_count(Encoder *encoder, uint8_t copy_count)
 {
-    spice_return_if_fail(encoder->io_last_copy);
+    g_return_if_fail(encoder->io_last_copy);
     *(encoder->io_last_copy) = copy_count;
 }
 
@@ -266,12 +266,12 @@ static inline void compress_output_prev(Encoder *encoder)
     // io_now cannot be the first byte of the buffer
     encoder->io_now--;
     // the function should be called only when copy count is written unnecessarily by lz_compress
-    spice_return_if_fail(encoder->io_now == encoder->io_last_copy);
+    g_return_if_fail(encoder->io_now == encoder->io_last_copy);
 }
 
 static int encoder_reset(Encoder *encoder, uint8_t *io_ptr, uint8_t *io_ptr_end)
 {
-    spice_return_val_if_fail(io_ptr <= io_ptr_end, FALSE);
+    g_return_val_if_fail(io_ptr <= io_ptr_end, FALSE);
 
     encoder->io_bytes_count = io_ptr_end - io_ptr;
     encoder->io_start = io_ptr;
@@ -289,9 +289,9 @@ static inline uint8_t decode(Encoder *encoder)
         if (num_io_bytes <= 0) {
             encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
         }
-        spice_assert(encoder->io_now);
+        g_assert(encoder->io_now);
     }
-    spice_assert(encoder->io_now < encoder->io_end);
+    g_assert(encoder->io_now < encoder->io_end);
     return *(encoder->io_now++);
 }
 
@@ -709,7 +709,7 @@ void lz_decode(LzContext *lz, LzImageType to_type, uint8_t *buf)
             if (encoder->type == to_type) {
                 out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
                 alpha_size = lz_rgb_alpha_decompress(encoder, (rgb32_pixel_t *)buf, size);
-                spice_assert(alpha_size == size);
+                g_assert(alpha_size == size);
             } else {
                 encoder->usr->error(encoder->usr, "unsupported output format\n");
             }
@@ -744,8 +744,8 @@ void lz_decode(LzContext *lz, LzImageType to_type, uint8_t *buf)
         }
     }
 
-    spice_assert(is_io_to_decode_end(encoder));
-    spice_assert(out_size == size);
+    g_assert(is_io_to_decode_end(encoder));
+    g_assert(out_size == size);
 
     if (out_size != size) {
         encoder->usr->error(encoder->usr, "bad decode size\n");
diff --git a/common/lz_decompress_tmpl.c b/common/lz_decompress_tmpl.c
index 04a5121..bc1ee96 100644
--- a/common/lz_decompress_tmpl.c
+++ b/common/lz_decompress_tmpl.c
@@ -270,9 +270,9 @@ static size_t FNAME(decompress)(Encoder *encoder, OUT_PIXEL *out_buf, int size)
 #endif
             ref -= ofs;
 
-            spice_assert(op + len <= op_limit);
-            spice_assert(ref + len <= op_limit);
-            spice_assert(ref >= out_buf);
+            g_assert(op + len <= op_limit);
+            g_assert(ref + len <= op_limit);
+            g_assert(ref >= out_buf);
 
             // TODO: optimize by not calling loop at least 3 times when not PLT_TO_RGB32 (len is
             //       always >=3). in PLT_TO_RGB32 len >= 3*number_of_pixels_per_byte
@@ -286,29 +286,29 @@ static size_t FNAME(decompress)(Encoder *encoder, OUT_PIXEL *out_buf, int size)
                 OUT_PIXEL b = *ref;
                 for (; len; --len) {
                     COPY_PIXEL(b, op);
-                    spice_assert(op <= op_limit);
+                    g_assert(op <= op_limit);
                 }
             } else {
                 for (; len; --len) {
                     COPY_REF_PIXEL(ref, op);
-                    spice_assert(op <= op_limit);
+                    g_assert(op <= op_limit);
                 }
             }
         } else { // copy
             ctrl++; // copy count is biased by 1
 #if defined(TO_RGB32) && (defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || \
                                                                                    defined(PLT1_LE))
-            spice_assert(op + CAST_PLT_DISTANCE(ctrl) <= op_limit);
+            g_assert(op + CAST_PLT_DISTANCE(ctrl) <= op_limit);
 #else
-            spice_assert(op + ctrl <= op_limit);
+            g_assert(op + ctrl <= op_limit);
 #endif
             COPY_COMP_PIXEL(encoder, op);
 
-            spice_assert(op <= op_limit);
+            g_assert(op <= op_limit);
 
             for (--ctrl; ctrl; ctrl--) {
                 COPY_COMP_PIXEL(encoder, op);
-                spice_assert(op <= op_limit);
+                g_assert(op <= op_limit);
             }
         }
 
diff --git a/common/marshaller.c b/common/marshaller.c
index 2fccd52..13fee9a 100644
--- a/common/marshaller.c
+++ b/common/marshaller.c
@@ -626,7 +626,7 @@ void *spice_marshaller_add_int8(SpiceMarshaller *m, int8_t v)
 
 void spice_marshaller_add_fd(SpiceMarshaller *m, int fd)
 {
-    spice_assert(m->has_fd == false);
+    g_assert(m->has_fd == false);
 
     m->has_fd = true;
     if (fd != -1) {
diff --git a/common/mem.c b/common/mem.c
index e430b5d..33d656d 100644
--- a/common/mem.c
+++ b/common/mem.c
@@ -26,7 +26,7 @@
 
 #ifndef MALLOC_ERROR
 #define MALLOC_ERROR(format, ...) SPICE_STMT_START {    \
-    spice_error(format, ## __VA_ARGS__);                \
+    g_error(format, ## __VA_ARGS__);                \
     abort();                                            \
 } SPICE_STMT_END
 #endif
diff --git a/common/pixman_utils.c b/common/pixman_utils.c
index 81806c9..bafb1ab 100644
--- a/common/pixman_utils.c
+++ b/common/pixman_utils.c
@@ -213,12 +213,12 @@ void spice_pixman_fill_rect(pixman_image_t *dest,
     depth = spice_pixman_image_get_bpp(dest);
     /* stride is in bytes, depth in bits */
 
-    spice_assert(x >= 0);
-    spice_assert(y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(x + width <= pixman_image_get_width(dest));
-    spice_assert(y + height <= pixman_image_get_height(dest));
+    g_assert(x >= 0);
+    g_assert(y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(x + width <= pixman_image_get_width(dest));
+    g_assert(y + height <= pixman_image_get_height(dest));
 
     if (pixman_fill(bits,
                     stride / 4,
@@ -238,7 +238,7 @@ void spice_pixman_fill_rect(pixman_image_t *dest,
         byte_width = 2 * width;
         value = (value & 0xffff) * 0x00010001;
     } else {
-        spice_assert (depth == 32);
+        g_assert (depth == 32);
         byte_line = ((uint8_t *)bits) + stride * y + x * 4;
         byte_width = 4 * width;
     }
@@ -305,13 +305,13 @@ void spice_pixman_fill_rect_rop(pixman_image_t *dest,
     depth = spice_pixman_image_get_bpp(dest);
     /* stride is in bytes, depth in bits */
 
-    spice_assert(x >= 0);
-    spice_assert(y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(x + width <= pixman_image_get_width(dest));
-    spice_assert(y + height <= pixman_image_get_height(dest));
-    spice_assert(rop < 16);
+    g_assert(x >= 0);
+    g_assert(y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(x + width <= pixman_image_get_width(dest));
+    g_assert(y + height <= pixman_image_get_height(dest));
+    g_assert(rop < 16);
 
     if (depth == 8) {
         solid_rop_8_func_t rop_func = solid_rops_8[rop];
@@ -365,13 +365,13 @@ void spice_pixman_tile_rect(pixman_image_t *dest,
     tile_width = pixman_image_get_width(tile);
     tile_height = pixman_image_get_height(tile);
 
-    spice_assert(x >= 0);
-    spice_assert(y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(x + width <= pixman_image_get_width(dest));
-    spice_assert(y + height <= pixman_image_get_height(dest));
-    spice_assert(depth == spice_pixman_image_get_bpp(tile));
+    g_assert(x >= 0);
+    g_assert(y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(x + width <= pixman_image_get_width(dest));
+    g_assert(y + height <= pixman_image_get_height(dest));
+    g_assert(depth == spice_pixman_image_get_bpp(tile));
 
     tile_start_x = (x - offset_x) % tile_width;
     if (tile_start_x < 0) {
@@ -413,7 +413,7 @@ void spice_pixman_tile_rect(pixman_image_t *dest,
             }
         }
     }  else {
-        spice_assert (depth == 32);
+        g_assert (depth == 32);
 
         byte_line = ((uint8_t *)bits) + stride * y + x * 4;
         tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x * 4;
@@ -456,14 +456,14 @@ void spice_pixman_tile_rect_rop(pixman_image_t *dest,
     tile_width = pixman_image_get_width(tile);
     tile_height = pixman_image_get_height(tile);
 
-    spice_assert(x >= 0);
-    spice_assert(y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(x + width <= pixman_image_get_width(dest));
-    spice_assert(y + height <= pixman_image_get_height(dest));
-    spice_assert(rop < 16);
-    spice_assert(depth == spice_pixman_image_get_bpp(tile));
+    g_assert(x >= 0);
+    g_assert(y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(x + width <= pixman_image_get_width(dest));
+    g_assert(y + height <= pixman_image_get_height(dest));
+    g_assert(rop < 16);
+    g_assert(depth == spice_pixman_image_get_bpp(tile));
 
     tile_start_x = (x - offset_x) % tile_width;
     if (tile_start_x < 0) {
@@ -511,7 +511,7 @@ void spice_pixman_tile_rect_rop(pixman_image_t *dest,
     }  else {
         tiled_rop_32_func_t rop_func = tiled_rops_32[rop];
 
-        spice_assert (depth == 32);
+        g_assert (depth == 32);
 
         byte_line = ((uint8_t *)bits) + stride * y + x * 4;
         tile_line = ((uint8_t *)tile_bits) + tile_stride * tile_start_y + tile_start_x * 4;
@@ -581,17 +581,17 @@ void spice_pixman_blit(pixman_image_t *dest,
         return;
     }
 
-    spice_assert(src_x >= 0);
-    spice_assert(src_y >= 0);
-    spice_assert(dest_x >= 0);
-    spice_assert(dest_y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(dest_x + width <= pixman_image_get_width(dest));
-    spice_assert(dest_y + height <= pixman_image_get_height(dest));
-    spice_assert(src_x + width <= pixman_image_get_width(src));
-    spice_assert(src_y + height <= pixman_image_get_height(src));
-    spice_assert(depth == src_depth);
+    g_assert(src_x >= 0);
+    g_assert(src_y >= 0);
+    g_assert(dest_x >= 0);
+    g_assert(dest_y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(dest_x + width <= pixman_image_get_width(dest));
+    g_assert(dest_y + height <= pixman_image_get_height(dest));
+    g_assert(src_x + width <= pixman_image_get_width(src));
+    g_assert(src_y + height <= pixman_image_get_height(src));
+    g_assert(depth == src_depth);
 
     if (pixman_blt(src_bits,
                    bits,
@@ -613,7 +613,7 @@ void spice_pixman_blit(pixman_image_t *dest,
         byte_width = width * 2;
         src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 2;
     }  else {
-        spice_assert (depth == 32);
+        g_assert (depth == 32);
         byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 4;
         byte_width = width * 4;
         src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 4;
@@ -672,17 +672,17 @@ void spice_pixman_blit_rop (pixman_image_t *dest,
         return;
     }
 
-    spice_assert(src_x >= 0);
-    spice_assert(src_y >= 0);
-    spice_assert(dest_x >= 0);
-    spice_assert(dest_y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(dest_x + width <= pixman_image_get_width(dest));
-    spice_assert(dest_y + height <= pixman_image_get_height(dest));
-    spice_assert(src_x + width <= pixman_image_get_width(src));
-    spice_assert(src_y + height <= pixman_image_get_height(src));
-    spice_assert(depth == src_depth);
+    g_assert(src_x >= 0);
+    g_assert(src_y >= 0);
+    g_assert(dest_x >= 0);
+    g_assert(dest_y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(dest_x + width <= pixman_image_get_width(dest));
+    g_assert(dest_y + height <= pixman_image_get_height(dest));
+    g_assert(src_x + width <= pixman_image_get_width(src));
+    g_assert(src_y + height <= pixman_image_get_height(src));
+    g_assert(depth == src_depth);
 
     if (depth == 8) {
         copy_rop_8_func_t rop_func = copy_rops_8[rop];
@@ -709,7 +709,7 @@ void spice_pixman_blit_rop (pixman_image_t *dest,
     }  else {
         copy_rop_32_func_t rop_func = copy_rops_32[rop];
 
-        spice_assert (depth == 32);
+        g_assert (depth == 32);
         byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 4;
         src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 4;
 
@@ -768,17 +768,17 @@ void spice_pixman_blit_colorkey (pixman_image_t *dest,
         return;
     }
 
-    spice_assert(src_x >= 0);
-    spice_assert(src_y >= 0);
-    spice_assert(dest_x >= 0);
-    spice_assert(dest_y >= 0);
-    spice_assert(width > 0);
-    spice_assert(height > 0);
-    spice_assert(dest_x + width <= pixman_image_get_width(dest));
-    spice_assert(dest_y + height <= pixman_image_get_height(dest));
-    spice_assert(src_x + width <= pixman_image_get_width(src));
-    spice_assert(src_y + height <= pixman_image_get_height(src));
-    spice_assert(depth == spice_pixman_image_get_bpp(src));
+    g_assert(src_x >= 0);
+    g_assert(src_y >= 0);
+    g_assert(dest_x >= 0);
+    g_assert(dest_y >= 0);
+    g_assert(width > 0);
+    g_assert(height > 0);
+    g_assert(dest_x + width <= pixman_image_get_width(dest));
+    g_assert(dest_y + height <= pixman_image_get_height(dest));
+    g_assert(src_x + width <= pixman_image_get_width(src));
+    g_assert(src_y + height <= pixman_image_get_height(src));
+    g_assert(depth == spice_pixman_image_get_bpp(src));
 
     if (depth == 8) {
         byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x;
@@ -818,7 +818,7 @@ void spice_pixman_blit_colorkey (pixman_image_t *dest,
             src_line += src_stride;
         }
     }  else {
-        spice_assert (depth == 32);
+        g_assert (depth == 32);
         byte_line = ((uint8_t *)bits) + stride * dest_y + dest_x * 4;
         src_line = ((uint8_t *)src_bits) + src_stride * src_y + src_x * 4;
 
@@ -1143,7 +1143,7 @@ static void bitmap_8_32_to_32(uint8_t *dest, int dest_stride,
 #endif
 
     if (!palette) {
-        spice_error("No palette");
+        g_error("No palette");
         return;
     }
 
@@ -1189,7 +1189,7 @@ static void bitmap_8_16_to_16_555(uint8_t *dest, int dest_stride,
 #endif
 
     if (!palette) {
-        spice_error("No palette");
+        g_error("No palette");
         return;
     }
 
@@ -1235,7 +1235,7 @@ static void bitmap_4be_32_to_32(uint8_t* dest, int dest_stride,
 #endif
 
     if (!palette) {
-        spice_error("No palette");
+        g_error("No palette");
         return;
     }
 
@@ -1285,7 +1285,7 @@ static void bitmap_4be_16_to_16_555(uint8_t* dest, int dest_stride,
 #endif
 
     if (!palette) {
-        spice_error("No palette");
+        g_error("No palette");
         return;
     }
 
@@ -1335,7 +1335,7 @@ static void bitmap_1be_32_to_32(uint8_t* dest, int dest_stride,
     uint32_t fore_color;
     uint32_t back_color;
 
-    spice_assert(palette != NULL);
+    g_assert(palette != NULL);
 
     if (!palette) {
         return;
@@ -1367,7 +1367,7 @@ static void bitmap_1be_16_to_16_555(uint8_t* dest, int dest_stride,
     uint16_t fore_color;
     uint16_t back_color;
 
-    spice_assert(palette != NULL);
+    g_assert(palette != NULL);
 
     if (!palette) {
         return;
@@ -1473,7 +1473,7 @@ pixman_image_t *spice_bitmap_to_pixman(pixman_image_t *dest_image,
     dest = (uint8_t *)pixman_image_get_data(dest_image);
     dest_stride = pixman_image_get_stride(dest_image);
     if (!(flags & SPICE_BITMAP_FLAGS_TOP_DOWN)) {
-        spice_assert(height > 0);
+        g_assert(height > 0);
         dest += dest_stride * (height - 1);
         dest_stride = -dest_stride;
     }
@@ -1500,7 +1500,7 @@ pixman_image_t *spice_bitmap_to_pixman(pixman_image_t *dest_image,
         } else if (palette_surface_format == SPICE_SURFACE_FMT_16_555) {
             bitmap_8_16_to_16_555(dest, dest_stride, src, src_stride, width, end, palette);
         } else {
-            spice_error("Unsupported palette format");
+            g_error("Unsupported palette format");
         }
         break;
     case SPICE_BITMAP_FMT_4BIT_BE:
@@ -1510,7 +1510,7 @@ pixman_image_t *spice_bitmap_to_pixman(pixman_image_t *dest_image,
         } else if (palette_surface_format == SPICE_SURFACE_FMT_16_555) {
             bitmap_4be_16_to_16_555(dest, dest_stride, src, src_stride, width, end, palette);
         } else {
-            spice_error("Unsupported palette format");
+            g_error("Unsupported palette format");
         }
         break;
     case SPICE_BITMAP_FMT_1BIT_BE:
@@ -1520,11 +1520,11 @@ pixman_image_t *spice_bitmap_to_pixman(pixman_image_t *dest_image,
         } else if (palette_surface_format == SPICE_SURFACE_FMT_16_555) {
             bitmap_1be_16_to_16_555(dest, dest_stride, src, src_stride, width, end, palette);
         } else {
-            spice_error("Unsupported palette format");
+            g_error("Unsupported palette format");
         }
         break;
     default:
-        spice_error("Unsupported bitmap format");
+        g_error("Unsupported bitmap format");
         break;
     }
 
diff --git a/common/quic.c b/common/quic.c
index 5b00d65..3f84608 100644
--- a/common/quic.c
+++ b/common/quic.c
@@ -237,8 +237,8 @@ static const unsigned int tabrand_chaos[TABRAND_TABSIZE] = {
 
 static unsigned int stabrand(void)
 {
-    //spice_assert( !(TABRAND_SEEDMASK & TABRAND_TABSIZE));
-    //spice_assert( TABRAND_SEEDMASK + 1 == TABRAND_TABSIZE );
+    //g_assert( !(TABRAND_SEEDMASK & TABRAND_TABSIZE));
+    //g_assert( TABRAND_SEEDMASK + 1 == TABRAND_TABSIZE );
 
     return TABRAND_SEEDMASK;
 }
@@ -263,19 +263,19 @@ static void set_wm_trigger(CommonState *state)
         wm = 10;
     }
 
-    spice_assert(evol < 6);
+    g_assert(evol < 6);
 
     state->wm_trigger = besttrigtab[evol / 2][wm];
 
-    spice_assert(state->wm_trigger <= 2000);
-    spice_assert(state->wm_trigger >= 1);
+    g_assert(state->wm_trigger <= 2000);
+    g_assert(state->wm_trigger >= 1);
 }
 
 static int ceil_log_2(int val) /* ceil(log_2(val)) */
 {
     int result;
 
-    //spice_assert(val>0);
+    //g_assert(val>0);
 
     if (val == 1) {
         return 0;
@@ -330,7 +330,7 @@ static void decorelate_init(QuicFamily *family, int bpc)
     const unsigned int pixelbitmaskshr = pixelbitmask >> 1;
     unsigned int s;
 
-    //spice_assert(bpc <= 8);
+    //g_assert(bpc <= 8);
 
     for (s = 0; s <= pixelbitmask; s++) {
         if (s <= pixelbitmaskshr) {
@@ -346,7 +346,7 @@ static void corelate_init(QuicFamily *family, int bpc)
     const unsigned long int pixelbitmask = bppmask[bpc];
     unsigned long int s;
 
-    //spice_assert(bpc <= 8);
+    //g_assert(bpc <= 8);
 
     for (s = 0; s <= pixelbitmask; s++) {
         if (s & 0x01) {
@@ -408,7 +408,7 @@ static void more_io_words(Encoder *encoder)
     if (num_io_words <= 0) {
         encoder->usr->error(encoder->usr, "%s: no more words\n", __FUNCTION__);
     }
-    spice_assert(io_ptr);
+    g_assert(io_ptr);
     encoder->io_words_count += num_io_words;
     encoder->io_now = io_ptr;
     encoder->io_end = encoder->io_now + num_io_words;
@@ -435,8 +435,8 @@ static inline void encode(Encoder *encoder, unsigned int word, unsigned int len)
 {
     int delta;
 
-    spice_assert(len > 0 && len < 32);
-    spice_assert(!(word & ~bppmask[len]));
+    g_assert(len > 0 && len < 32);
+    g_assert(!(word & ~bppmask[len]));
     if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
         encoder->io_available_bits = delta;
         encoder->io_word |= word << encoder->io_available_bits;
@@ -448,8 +448,8 @@ static inline void encode(Encoder *encoder, unsigned int word, unsigned int len)
     encoder->io_available_bits = 32 - delta;
     encoder->io_word = word << encoder->io_available_bits;
 
-    spice_assert(encoder->io_available_bits < 32);
-    spice_assert((encoder->io_word & bppmask[encoder->io_available_bits]) == 0);
+    g_assert(encoder->io_available_bits < 32);
+    g_assert((encoder->io_word & bppmask[encoder->io_available_bits]) == 0);
 }
 
 static inline void encode_32(Encoder *encoder, unsigned int word)
@@ -482,7 +482,7 @@ static inline void read_io_word(Encoder *encoder)
         __read_io_word_ptr(encoder); //disable inline optimizations
         return;
     }
-    spice_assert(encoder->io_now < encoder->io_end);
+    g_assert(encoder->io_now < encoder->io_end);
     encoder->io_next_word = GUINT32_FROM_LE(*(encoder->io_now++));
 }
 
@@ -490,7 +490,7 @@ static inline void decode_eatbits(Encoder *encoder, int len)
 {
     int delta;
 
-    spice_assert(len > 0 && len < 32);
+    g_assert(len > 0 && len < 32);
     encoder->io_word <<= len;
 
     if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
@@ -701,7 +701,7 @@ static inline void encode_run(Encoder *encoder, unsigned int len)
 
     while ((msb = spice_bit_find_msb(len))) {
         len &= ~(1 << (msb - 1));
-        spice_assert(msb < 32);
+        g_assert(msb < 32);
         encode(encoder, (1 << (msb)) - 1, msb);
         encode(encoder, 0, 1);
     }
@@ -723,7 +723,7 @@ static inline unsigned int decode_run(Encoder *encoder)
         while (encoder->io_word & (1U << 31)) {
             decode_eatbits(encoder, 1);
             count++;
-            spice_assert(count < 32);
+            g_assert(count < 32);
         }
         decode_eatbits(encoder, 1);
         len += (1U << count) >> 1;
@@ -855,10 +855,10 @@ static void fill_model_structures(SPICE_GNUC_UNUSED Encoder *encoder, FamilyStat
         family_stat->buckets_buf[bnumber].pcounters = free_counter;
         free_counter += ncounters;
 
-        spice_assert(bstart < n_buckets_ptrs);
+        g_assert(bstart < n_buckets_ptrs);
         {
             unsigned int i;
-            spice_assert(bend < n_buckets_ptrs);
+            g_assert(bend < n_buckets_ptrs);
             for (i = bstart; i <= bend; i++) {
                 family_stat->buckets_ptrs[i] = family_stat->buckets_buf + bnumber;
             }
@@ -867,7 +867,7 @@ static void fill_model_structures(SPICE_GNUC_UNUSED Encoder *encoder, FamilyStat
         bnumber++;
     } while (bend < levels - 1);
 
-    spice_assert(free_counter - family_stat->counters == nbuckets * ncounters);
+    g_assert(free_counter - family_stat->counters == nbuckets * ncounters);
 }
 
 static void find_model_params(Encoder *encoder,
@@ -888,8 +888,8 @@ static void find_model_params(Encoder *encoder,
     /* The only valid values are 1, 3 and 5.
        0, 2 and 4 are obsolete and the rest of the
        values are considered out of the range. */
-    spice_static_assert (evol == 1 || evol == 3 || evol == 5);
-    spice_assert(bpc <= 8 && bpc > 0);
+    G_STATIC_ASSERT (evol == 1 || evol == 3 || evol == 5);
+    g_assert(bpc <= 8 && bpc > 0);
 
     *ncounters = 8;
 
@@ -949,7 +949,7 @@ static void find_model_params(Encoder *encoder,
                 *n_buckets_ptrs = *levels;
             } else if (bsize >= 256) { /* this bucket is allowed to reside in the 2nd table */
                 b_lo_ptrs = bstart;
-                spice_assert(bstart);     /* previous bucket exists */
+                g_assert(bstart);     /* previous bucket exists */
             }
  #endif
         }
@@ -1073,8 +1073,8 @@ static int init_encoder(Encoder *encoder, QuicUsrContext *usr)
 
 static int encoder_reste(Encoder *encoder, uint32_t *io_ptr, uint32_t *io_ptr_end)
 {
-    spice_assert(((uintptr_t)io_ptr % 4) == ((uintptr_t)io_ptr_end % 4));
-    spice_assert(io_ptr <= io_ptr_end);
+    g_assert(((uintptr_t)io_ptr % 4) == ((uintptr_t)io_ptr_end % 4));
+    g_assert(io_ptr <= io_ptr_end);
 
     encoder->rgb_state.waitcnt = 0;
     encoder->rgb_state.tabrand_seed = stabrand();
@@ -1155,7 +1155,7 @@ static int encoder_reste_channels(Encoder *encoder, int channels, int width, int
 
 static void quic_image_params(Encoder *encoder, QuicImageType type, int *channels, int *bpc)
 {
-    spice_assert(channels && bpc);
+    g_assert(channels && bpc);
     switch (type) {
     case QUIC_IMAGE_TYPE_GRAY:
         *channels = 1;
@@ -1237,7 +1237,7 @@ int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
 
     lines_end = line + num_lines * stride;
     if (line == NULL && lines_end != line) {
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return QUIC_ERROR;
     }
 
@@ -1262,19 +1262,19 @@ int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
     switch (type) {
 #ifdef QUIC_RGB
     case QUIC_IMAGE_TYPE_RGB32:
-        spice_assert(ABS(stride) >= width * 4);
+        g_assert(ABS(stride) >= width * 4);
         QUIC_COMPRESS_RGB(32);
         break;
     case QUIC_IMAGE_TYPE_RGB24:
-        spice_assert(ABS(stride) >= width * 3);
+        g_assert(ABS(stride) >= width * 3);
         QUIC_COMPRESS_RGB(24);
         break;
     case QUIC_IMAGE_TYPE_RGB16:
-        spice_assert(ABS(stride) >= width * 2);
+        g_assert(ABS(stride) >= width * 2);
         QUIC_COMPRESS_RGB(16);
         break;
     case QUIC_IMAGE_TYPE_RGBA:
-        spice_assert(ABS(stride) >= width * 4);
+        g_assert(ABS(stride) >= width * 4);
 
         encoder->channels[0].correlate_row[-1] = 0;
         encoder->channels[1].correlate_row[-1] = 0;
@@ -1302,7 +1302,7 @@ int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
         break;
 #else
     case QUIC_IMAGE_TYPE_RGB24:
-        spice_assert(ABS(stride) >= width * 3);
+        g_assert(ABS(stride) >= width * 3);
         for (i = 0; i < 3; i++) {
             encoder->channels[i].correlate_row[-1] = 0;
             quic_three_compress_row0(encoder, &encoder->channels[i], (three_bytes_t *)(line + i),
@@ -1322,7 +1322,7 @@ int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
         break;
     case QUIC_IMAGE_TYPE_RGB32:
     case QUIC_IMAGE_TYPE_RGBA:
-        spice_assert(ABS(stride) >= width * 4);
+        g_assert(ABS(stride) >= width * 4);
         for (i = 0; i < channels; i++) {
             encoder->channels[i].correlate_row[-1] = 0;
             quic_four_compress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(line + i),
@@ -1342,7 +1342,7 @@ int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
         break;
 #endif
     case QUIC_IMAGE_TYPE_GRAY:
-        spice_assert(ABS(stride) >= width);
+        g_assert(ABS(stride) >= width);
         encoder->channels[0].correlate_row[-1] = 0;
         quic_one_compress_row0(encoder, &encoder->channels[0], (one_byte_t *)line, width);
         encoder->rows_completed++;
@@ -1512,18 +1512,18 @@ int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
     int i;
 #endif
 
-    spice_assert(buf);
+    g_assert(buf);
 
     switch (encoder->type) {
 #ifdef QUIC_RGB
     case QUIC_IMAGE_TYPE_RGB32:
     case QUIC_IMAGE_TYPE_RGB24:
         if (type == QUIC_IMAGE_TYPE_RGB32) {
-            spice_assert(ABS(stride) >= (int)encoder->width * 4);
+            g_assert(ABS(stride) >= (int)encoder->width * 4);
             QUIC_UNCOMPRESS_RGB(32, rgb32_pixel_t);
             break;
         } else if (type == QUIC_IMAGE_TYPE_RGB24) {
-            spice_assert(ABS(stride) >= (int)encoder->width * 3);
+            g_assert(ABS(stride) >= (int)encoder->width * 3);
             QUIC_UNCOMPRESS_RGB(24, rgb24_pixel_t);
             break;
         }
@@ -1531,10 +1531,10 @@ int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
         return QUIC_ERROR;
     case QUIC_IMAGE_TYPE_RGB16:
         if (type == QUIC_IMAGE_TYPE_RGB16) {
-            spice_assert(ABS(stride) >= (int)encoder->width * 2);
+            g_assert(ABS(stride) >= (int)encoder->width * 2);
             QUIC_UNCOMPRESS_RGB(16, rgb16_pixel_t);
         } else if (type == QUIC_IMAGE_TYPE_RGB32) {
-            spice_assert(ABS(stride) >= (int)encoder->width * 4);
+            g_assert(ABS(stride) >= (int)encoder->width * 4);
             QUIC_UNCOMPRESS_RGB(16_to_32, rgb32_pixel_t);
         } else {
             encoder->usr->warn(encoder->usr, "unsupported output format\n");
@@ -1548,12 +1548,12 @@ int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
             encoder->usr->warn(encoder->usr, "unsupported output format\n");
             return QUIC_ERROR;
         }
-        spice_assert(ABS(stride) >= (int)encoder->width * 4);
+        g_assert(ABS(stride) >= (int)encoder->width * 4);
         uncompress_rgba(encoder, buf, stride);
         break;
 #else
     case QUIC_IMAGE_TYPE_RGB24:
-        spice_assert(ABS(stride) >= (int)encoder->width * 3);
+        g_assert(ABS(stride) >= (int)encoder->width * 3);
         for (i = 0; i < 3; i++) {
             encoder->channels[i].correlate_row[-1] = 0;
             quic_three_uncompress_row0(encoder, &encoder->channels[i], (three_bytes_t *)(buf + i),
@@ -1574,7 +1574,7 @@ int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
         }
         break;
     case QUIC_IMAGE_TYPE_RGB32:
-        spice_assert(ABS(stride) >= encoder->width * 4);
+        g_assert(ABS(stride) >= encoder->width * 4);
         for (i = 0; i < 3; i++) {
             encoder->channels[i].correlate_row[-1] = 0;
             quic_four_uncompress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(buf + i),
@@ -1597,7 +1597,7 @@ int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
         }
         break;
     case QUIC_IMAGE_TYPE_RGBA:
-        spice_assert(ABS(stride) >= encoder->width * 4);
+        g_assert(ABS(stride) >= encoder->width * 4);
         for (i = 0; i < 4; i++) {
             encoder->channels[i].correlate_row[-1] = 0;
             quic_four_uncompress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(buf + i),
@@ -1624,7 +1624,7 @@ int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
             encoder->usr->warn(encoder->usr, "unsupported output format\n");
             return QUIC_ERROR;
         }
-        spice_assert(ABS(stride) >= (int)encoder->width);
+        g_assert(ABS(stride) >= (int)encoder->width);
         uncompress_gray(encoder, buf, stride);
         break;
     case QUIC_IMAGE_TYPE_INVALID:
diff --git a/common/quic_family_tmpl.c b/common/quic_family_tmpl.c
index 9a434e0..26bf226 100644
--- a/common/quic_family_tmpl.c
+++ b/common/quic_family_tmpl.c
@@ -71,8 +71,8 @@ static unsigned int FNAME(golomb_decoding)(const unsigned int l, const unsigned
 static void FNAME(update_model)(CommonState *state, s_bucket * const bucket,
                                 const BYTE curval)
 {
-    spice_static_assert(BPC >= 1);
-    spice_return_if_fail (bucket != NULL);
+    G_STATIC_ASSERT(BPC >= 1);
+    g_return_if_fail (bucket != NULL);
 
     const unsigned int bpp = BPC;
     COUNTER * const pcounters = bucket->pcounters;
@@ -105,7 +105,7 @@ static void FNAME(update_model)(CommonState *state, s_bucket * const bucket,
 
 static s_bucket *FNAME(find_bucket)(Channel *channel, const unsigned int val)
 {
-    spice_assert(val < (0x1U << BPC));
+    g_assert(val < (0x1U << BPC));
 
     return channel->_buckets_ptrs[val];
 }
diff --git a/common/quic_rgb_tmpl.c b/common/quic_rgb_tmpl.c
index f807a0c..f50efb9 100644
--- a/common/quic_rgb_tmpl.c
+++ b/common/quic_rgb_tmpl.c
@@ -235,7 +235,7 @@ static void FNAME(compress_row0_seg)(Encoder *encoder, int i,
     BYTE * const correlate_row_b = channel_b->correlate_row;
     int stopidx;
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (!i) {
         unsigned int codeword, codewordlen;
@@ -305,9 +305,9 @@ static void FNAME(compress_row0)(Encoder *encoder, const PIXEL *cur_row,
         }
     }
 
-    spice_assert((int)encoder->rgb_state.wmidx <= wmimax);
-    spice_assert(encoder->rgb_state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)encoder->rgb_state.wmidx <= wmimax);
+    g_assert(encoder->rgb_state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 #define COMPRESS_ONE_0(channel) \
@@ -347,7 +347,7 @@ static void FNAME(compress_row_seg)(Encoder *encoder, int i,
     int run_size;
 #endif
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (!i) {
         unsigned int codeword, codewordlen;
@@ -451,9 +451,9 @@ static void FNAME(compress_row)(Encoder *encoder,
         }
     }
 
-    spice_assert((int)encoder->rgb_state.wmidx <= wmimax);
-    spice_assert(encoder->rgb_state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)encoder->rgb_state.wmidx <= wmimax);
+    g_assert(encoder->rgb_state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 #endif
@@ -490,7 +490,7 @@ static void FNAME(uncompress_row0_seg)(Encoder *encoder, int i,
     BYTE * const correlate_row_b = channel_b->correlate_row;
     int stopidx;
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (!i) {
         unsigned int codewordlen;
@@ -567,9 +567,9 @@ static void FNAME(uncompress_row0)(Encoder *encoder,
         }
     }
 
-    spice_assert((int)encoder->rgb_state.wmidx <= wmimax);
-    spice_assert(encoder->rgb_state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)encoder->rgb_state.wmidx <= wmimax);
+    g_assert(encoder->rgb_state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 #define UNCOMPRESS_ONE_0(channel) \
@@ -611,7 +611,7 @@ static void FNAME(uncompress_row_seg)(Encoder *encoder,
     int run_end;
 #endif
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (!i) {
         unsigned int codewordlen;
@@ -721,9 +721,9 @@ static void FNAME(uncompress_row)(Encoder *encoder,
         }
     }
 
-    spice_assert((int)encoder->rgb_state.wmidx <= wmimax);
-    spice_assert(encoder->rgb_state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)encoder->rgb_state.wmidx <= wmimax);
+    g_assert(encoder->rgb_state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 #undef PIXEL
diff --git a/common/quic_tmpl.c b/common/quic_tmpl.c
index e839346..26a87e1 100644
--- a/common/quic_tmpl.c
+++ b/common/quic_tmpl.c
@@ -158,7 +158,7 @@ static void FNAME(compress_row0_seg)(Encoder *encoder, Channel *channel, int i,
     BYTE * const decorelate_drow = channel->correlate_row;
     int stopidx;
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (i == 0) {
         unsigned int codeword, codewordlen;
@@ -233,9 +233,9 @@ static void FNAME(compress_row0)(Encoder *encoder, Channel *channel, const PIXEL
         }
     }
 
-    spice_assert((int)channel->state.wmidx <= wmimax);
-    spice_assert(channel->state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)channel->state.wmidx <= wmimax);
+    g_assert(channel->state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 static void FNAME(compress_row_seg)(Encoder *encoder, Channel *channel, int i,
@@ -253,7 +253,7 @@ static void FNAME(compress_row_seg)(Encoder *encoder, Channel *channel, int i,
     int run_size;
 #endif
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (!i) {
         unsigned int codeword, codewordlen;
@@ -375,9 +375,9 @@ static void FNAME(compress_row)(Encoder *encoder, Channel *channel,
         }
     }
 
-    spice_assert((int)channel->state.wmidx <= wmimax);
-    spice_assert(channel->state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)channel->state.wmidx <= wmimax);
+    g_assert(channel->state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 static void FNAME(uncompress_row0_seg)(Encoder *encoder, Channel *channel, int i,
@@ -390,7 +390,7 @@ static void FNAME(uncompress_row0_seg)(Encoder *encoder, Channel *channel, int i
 {
     int stopidx;
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (i == 0) {
         unsigned int codewordlen;
@@ -475,9 +475,9 @@ static void FNAME(uncompress_row0)(Encoder *encoder, Channel *channel,
         }
     }
 
-    spice_assert((int)channel->state.wmidx <= wmimax);
-    spice_assert(channel->state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)channel->state.wmidx <= wmimax);
+    g_assert(channel->state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 static void FNAME(uncompress_row_seg)(Encoder *encoder, Channel *channel,
@@ -496,7 +496,7 @@ static void FNAME(uncompress_row_seg)(Encoder *encoder, Channel *channel,
     int run_end;
 #endif
 
-    spice_assert(end - i > 0);
+    g_assert(end - i > 0);
 
     if (i == 0) {
         unsigned int codewordlen;
@@ -613,9 +613,9 @@ static void FNAME(uncompress_row)(Encoder *encoder, Channel *channel,
         }
     }
 
-    spice_assert((int)channel->state.wmidx <= wmimax);
-    spice_assert(channel->state.wmidx <= 32);
-    spice_assert(wminext > 0);
+    g_assert((int)channel->state.wmidx <= wmimax);
+    g_assert(channel->state.wmidx <= 32);
+    g_assert(wminext > 0);
 }
 
 #undef PIXEL
diff --git a/common/rect.h b/common/rect.h
index 8c9faed..a477d07 100644
--- a/common/rect.h
+++ b/common/rect.h
@@ -88,7 +88,7 @@ static inline int rect_get_area(const SpiceRect *r)
 
 static inline void rect_debug(const SpiceRect *r)
 {
-    spice_debug("(%d, %d) (%d, %d)", r->left, r->top, r->right, r->bottom);
+    g_debug("(%d, %d) (%d, %d)", r->left, r->top, r->right, r->bottom);
 }
 
 SPICE_END_DECLS
diff --git a/common/region.c b/common/region.c
index e9abb32..c5dea29 100644
--- a/common/region.c
+++ b/common/region.c
@@ -573,7 +573,7 @@ static void rect_set(SpiceRect *r, int32_t top, int32_t left, int32_t bottom, in
     r->left = left;
     r->bottom = bottom;
     r->right = right;
-    spice_assert(rect_is_valid(r));
+    g_assert(rect_is_valid(r));
 }
 
 static void random_region(QRegion *reg)
diff --git a/common/ring.h b/common/ring.h
index 4b0e313..a8c666f 100644
--- a/common/ring.h
+++ b/common/ring.h
@@ -46,14 +46,14 @@ static inline int ring_item_is_linked(RingItem *item)
 
 static inline int ring_is_empty(Ring *ring)
 {
-    spice_assert(ring->next != NULL && ring->prev != NULL);
+    g_assert(ring->next != NULL && ring->prev != NULL);
     return ring == ring->next;
 }
 
 static inline void ring_add(Ring *ring, RingItem *item)
 {
-    spice_assert(ring->next != NULL && ring->prev != NULL);
-    spice_assert(item->next == NULL && item->prev == NULL);
+    g_assert(ring->next != NULL && ring->prev != NULL);
+    g_assert(item->next == NULL && item->prev == NULL);
 
     item->next = ring->next;
     item->prev = ring;
@@ -79,8 +79,8 @@ static inline void __ring_remove(RingItem *item)
 
 static inline void ring_remove(RingItem *item)
 {
-    spice_assert(item->next != NULL && item->prev != NULL);
-    spice_assert(item->next != item);
+    g_assert(item->next != NULL && item->prev != NULL);
+    g_assert(item->next != item);
 
     __ring_remove(item);
 }
@@ -89,7 +89,7 @@ static inline RingItem *ring_get_head(Ring *ring)
 {
     RingItem *ret;
 
-    spice_assert(ring->next != NULL && ring->prev != NULL);
+    g_assert(ring->next != NULL && ring->prev != NULL);
 
     if (ring_is_empty(ring)) {
         return NULL;
@@ -102,7 +102,7 @@ static inline RingItem *ring_get_tail(Ring *ring)
 {
     RingItem *ret;
 
-    spice_assert(ring->next != NULL && ring->prev != NULL);
+    g_assert(ring->next != NULL && ring->prev != NULL);
 
     if (ring_is_empty(ring)) {
         return NULL;
@@ -115,9 +115,9 @@ static inline RingItem *ring_next(Ring *ring, RingItem *pos)
 {
     RingItem *ret;
 
-    spice_assert(ring->next != NULL && ring->prev != NULL);
-    spice_assert(pos);
-    spice_assert(pos->next != NULL && pos->prev != NULL);
+    g_assert(ring->next != NULL && ring->prev != NULL);
+    g_assert(pos);
+    g_assert(pos->next != NULL && pos->prev != NULL);
     ret = pos->next;
     return (ret == ring) ? NULL : ret;
 }
@@ -126,9 +126,9 @@ static inline RingItem *ring_prev(Ring *ring, RingItem *pos)
 {
     RingItem *ret;
 
-    spice_assert(ring->next != NULL && ring->prev != NULL);
-    spice_assert(pos);
-    spice_assert(pos->next != NULL && pos->prev != NULL);
+    g_assert(ring->next != NULL && ring->prev != NULL);
+    g_assert(pos);
+    g_assert(pos->next != NULL && pos->prev != NULL);
     ret = pos->prev;
     return (ret == ring) ? NULL : ret;
 }
diff --git a/common/rop3.c b/common/rop3.c
index 2a0a167..3bcc0a1 100644
--- a/common/rop3.c
+++ b/common/rop3.c
@@ -47,7 +47,7 @@ static void default_rop3_with_pattern_handler(SPICE_GNUC_UNUSED pixman_image_t *
                                               SPICE_GNUC_UNUSED pixman_image_t *p,
                                               SPICE_GNUC_UNUSED SpicePoint *pat_pos)
 {
-    spice_critical("not implemented");
+    g_critical("not implemented");
 }
 
 static void default_rop3_withe_color_handler(SPICE_GNUC_UNUSED pixman_image_t *d,
@@ -55,7 +55,7 @@ static void default_rop3_withe_color_handler(SPICE_GNUC_UNUSED pixman_image_t *d
                                              SPICE_GNUC_UNUSED SpicePoint *src_pos,
                                              SPICE_GNUC_UNUSED uint32_t rgb)
 {
-    spice_critical("not implemented");
+    g_critical("not implemented");
 }
 
 static void default_rop3_test_handler(void)
@@ -620,8 +620,8 @@ void do_rop3_with_pattern(uint8_t rop3, pixman_image_t *d, pixman_image_t *s, Sp
     int bpp;
 
     bpp = spice_pixman_image_get_bpp(d);
-    spice_assert(bpp == spice_pixman_image_get_bpp(s));
-    spice_assert(bpp == spice_pixman_image_get_bpp(p));
+    g_assert(bpp == spice_pixman_image_get_bpp(s));
+    g_assert(bpp == spice_pixman_image_get_bpp(p));
 
     if (bpp == 32) {
         rop3_with_pattern_handlers_32[rop3](d, s, src_pos, p, pat_pos);
@@ -636,7 +636,7 @@ void do_rop3_with_color(uint8_t rop3, pixman_image_t *d, pixman_image_t *s, Spic
     int bpp;
 
     bpp = spice_pixman_image_get_bpp(d);
-    spice_assert(bpp == spice_pixman_image_get_bpp(s));
+    g_assert(bpp == spice_pixman_image_get_bpp(s));
 
     if (bpp == 32) {
         rop3_with_color_handlers_32[rop3](d, s, src_pos, rgb);
diff --git a/common/snd_codec.c b/common/snd_codec.c
index 9738311..7b29413 100644
--- a/common/snd_codec.c
+++ b/common/snd_codec.c
@@ -85,14 +85,14 @@ static int snd_codec_create_celt051(SndCodecInternal *codec, int purpose)
                                            SND_CODEC_PLAYBACK_CHAN,
                                            SND_CODEC_CELT_FRAME_SIZE, &celt_error);
     if (! codec->celt_mode) {
-        spice_printerr("create celt mode failed %d", celt_error);
+        g_printerr("create celt mode failed %d", celt_error);
         return SND_CODEC_UNAVAILABLE;
     }
 
     if (purpose & SND_CODEC_ENCODE) {
         codec->celt_encoder = celt051_encoder_create(codec->celt_mode);
         if (! codec->celt_encoder) {
-            spice_printerr("create celt encoder failed");
+            g_printerr("create celt encoder failed");
             goto error;
         }
     }
@@ -100,7 +100,7 @@ static int snd_codec_create_celt051(SndCodecInternal *codec, int purpose)
     if (purpose & SND_CODEC_DECODE) {
         codec->celt_decoder = celt051_decoder_create(codec->celt_mode);
         if (! codec->celt_decoder) {
-            spice_printerr("create celt decoder failed");
+            g_printerr("create celt decoder failed");
             goto error;
         }
     }
@@ -120,7 +120,7 @@ static int snd_codec_encode_celt051(SndCodecInternal *codec, uint8_t *in_ptr, in
         return SND_CODEC_INVALID_ENCODE_SIZE;
     n = celt051_encode(codec->celt_encoder, (celt_int16_t *) in_ptr, NULL, out_ptr, *out_size);
     if (n < 0) {
-        spice_printerr("celt051_encode failed %d\n", n);
+        g_printerr("celt051_encode failed %d\n", n);
         return SND_CODEC_ENCODE_FAILED;
     }
     *out_size = n;
@@ -132,7 +132,7 @@ static int snd_codec_decode_celt051(SndCodecInternal *codec, uint8_t *in_ptr, in
     int n;
     n = celt051_decode(codec->celt_decoder, in_ptr, in_size, (celt_int16_t *) out_ptr);
     if (n < 0) {
-        spice_printerr("celt051_decode failed %d\n", n);
+        g_printerr("celt051_decode failed %d\n", n);
         return SND_CODEC_DECODE_FAILED;
     }
     *out_size = SND_CODEC_CELT_FRAME_SIZE * SND_CODEC_PLAYBACK_CHAN * 2 /* 16 fmt */;
@@ -166,7 +166,7 @@ static int snd_codec_create_opus(SndCodecInternal *codec, int purpose)
                                 SND_CODEC_PLAYBACK_CHAN,
                                 OPUS_APPLICATION_AUDIO, &opus_error);
         if (! codec->opus_encoder) {
-            spice_printerr("create opus encoder failed; error %d", opus_error);
+            g_printerr("create opus encoder failed; error %d", opus_error);
             goto error;
         }
     }
@@ -175,7 +175,7 @@ static int snd_codec_create_opus(SndCodecInternal *codec, int purpose)
         codec->opus_decoder = opus_decoder_create(codec->frequency,
                                 SND_CODEC_PLAYBACK_CHAN, &opus_error);
         if (! codec->opus_decoder) {
-            spice_printerr("create opus decoder failed; error %d", opus_error);
+            g_printerr("create opus decoder failed; error %d", opus_error);
             goto error;
         }
     }
@@ -195,7 +195,7 @@ static int snd_codec_encode_opus(SndCodecInternal *codec, uint8_t *in_ptr, int i
         return SND_CODEC_INVALID_ENCODE_SIZE;
     n = opus_encode(codec->opus_encoder, (opus_int16 *) in_ptr, SND_CODEC_OPUS_FRAME_SIZE, out_ptr, *out_size);
     if (n < 0) {
-        spice_printerr("opus_encode failed %d\n", n);
+        g_printerr("opus_encode failed %d\n", n);
         return SND_CODEC_ENCODE_FAILED;
     }
     *out_size = n;
@@ -208,7 +208,7 @@ static int snd_codec_decode_opus(SndCodecInternal *codec, uint8_t *in_ptr, int i
     n = opus_decode(codec->opus_decoder, in_ptr, in_size, (opus_int16 *) out_ptr,
                 *out_size / SND_CODEC_PLAYBACK_CHAN / 2, 0);
     if (n < 0) {
-        spice_printerr("opus_decode failed %d\n", n);
+        g_printerr("opus_decode failed %d\n", n);
         return SND_CODEC_DECODE_FAILED;
     }
     *out_size = n * SND_CODEC_PLAYBACK_CHAN * 2 /* 16 fmt */;
diff --git a/common/ssl_verify.c b/common/ssl_verify.c
index a9ed650..4b963bc 100644
--- a/common/ssl_verify.c
+++ b/common/ssl_verify.c
@@ -51,36 +51,36 @@ static int verify_pubkey(X509* cert, const char *key, size_t key_size)
         return 0;
 
     if (!cert) {
-        spice_debug("warning: no cert!");
+        g_debug("warning: no cert!");
         return 0;
     }
 
     cert_pubkey = X509_get_pubkey(cert);
     if (!cert_pubkey) {
-        spice_debug("warning: reading public key from certificate failed");
+        g_debug("warning: reading public key from certificate failed");
         goto finish;
     }
 
     bio = BIO_new_mem_buf((void*)key, key_size);
     if (!bio) {
-        spice_debug("creating BIO failed");
+        g_debug("creating BIO failed");
         goto finish;
     }
 
     orig_pubkey = d2i_PUBKEY_bio(bio, NULL);
     if (!orig_pubkey) {
-        spice_debug("reading pubkey from bio failed");
+        g_debug("reading pubkey from bio failed");
         goto finish;
     }
 
     ret = EVP_PKEY_cmp(orig_pubkey, cert_pubkey);
 
     if (ret == 1) {
-        spice_debug("public keys match");
+        g_debug("public keys match");
     } else if (ret == 0) {
-        spice_debug("public keys mismatch");
+        g_debug("public keys mismatch");
     } else {
-        spice_debug("public keys types mismatch");
+        g_debug("public keys types mismatch");
     }
 
 finish:
@@ -159,10 +159,10 @@ static int verify_hostname(X509* cert, const char *hostname)
     int cn_match = 0;
     X509_NAME* subject;
 
-    spice_return_val_if_fail(hostname != NULL, 0);
+    g_return_val_if_fail(hostname != NULL, 0);
 
     if (!cert) {
-        spice_debug("warning: no cert!");
+        g_debug("warning: no cert!");
         return 0;
     }
 
@@ -192,7 +192,7 @@ static int verify_hostname(X509* cert, const char *hostname)
                 if (_gnutls_hostname_compare((const char *)ASN1_STRING_get0_data(name->d.dNSName),
                                              ASN1_STRING_length(name->d.dNSName),
                                              hostname)) {
-                    spice_debug("alt name match=%s", ASN1_STRING_get0_data(name->d.dNSName));
+                    g_debug("alt name match=%s", ASN1_STRING_get0_data(name->d.dNSName));
                     GENERAL_NAMES_free(subject_alt_names);
                     return 1;
                 }
@@ -209,7 +209,7 @@ static int verify_hostname(X509* cert, const char *hostname)
                     ip_len = g_inet_address_get_native_size(ip);
                     ip_binary = g_inet_address_to_bytes(ip);
                 } else {
-                    spice_warning("Could not parse hostname: %s", hostname);
+                    g_warning("Could not parse hostname: %s", hostname);
                 }
 
                 alt_ip_len = ASN1_STRING_length(name->d.iPAddress);
@@ -222,7 +222,7 @@ static int verify_hostname(X509* cert, const char *hostname)
                     alt_ip = g_inet_address_new_from_bytes(ASN1_STRING_get0_data(name->d.iPAddress),
                                                            g_inet_address_get_family(ip));
                     alt_ip_string = g_inet_address_to_string(alt_ip);
-                    spice_debug("alt name IP match=%s", alt_ip_string);
+                    g_debug("alt name IP match=%s", alt_ip_string);
 
                     g_free(alt_ip_string);
                     g_object_unref(alt_ip);
@@ -239,7 +239,7 @@ static int verify_hostname(X509* cert, const char *hostname)
     }
 
     if (found_dns_name) {
-        spice_debug("warning: SubjectAltName mismatch");
+        g_debug("warning: SubjectAltName mismatch");
         return 0;
     }
 
@@ -263,7 +263,7 @@ static int verify_hostname(X509* cert, const char *hostname)
             if (_gnutls_hostname_compare((const char*)ASN1_STRING_get0_data(cn_asn1),
                                          ASN1_STRING_length(cn_asn1),
                                          hostname)) {
-                spice_debug("common name match=%s", (char*)ASN1_STRING_get0_data(cn_asn1));
+                g_debug("common name match=%s", (char*)ASN1_STRING_get0_data(cn_asn1));
                 cn_match = 1;
                 break;
             }
@@ -271,7 +271,7 @@ static int verify_hostname(X509* cert, const char *hostname)
     }
 
     if (!cn_match) {
-        spice_debug("warning: common name mismatch");
+        g_debug("warning: common name mismatch");
     }
 
     return cn_match;
@@ -287,15 +287,15 @@ static X509_NAME* subject_to_x509_name(const char *subject, int *nentries)
         VALUE
     } state;
 
-    spice_return_val_if_fail(subject != NULL, NULL);
-    spice_return_val_if_fail(nentries != NULL, NULL);
+    g_return_val_if_fail(subject != NULL, NULL);
+    g_return_val_if_fail(nentries != NULL, NULL);
 
     key = (char*)alloca(strlen(subject));
     val = (char*)alloca(strlen(subject));
     in_subject = X509_NAME_new();
 
     if (!in_subject || !key || !val) {
-        spice_debug("failed to allocate");
+        g_debug("failed to allocate");
         return NULL;
     }
 
@@ -308,7 +308,7 @@ static X509_NAME* subject_to_x509_name(const char *subject, int *nentries)
         if (*p == '\\') {
             ++p;
             if (*p != '\\' && *p != ',') {
-                spice_debug("Invalid character after \\");
+                g_debug("Invalid character after \\");
                 goto fail;
             }
             escape = 1;
@@ -342,7 +342,7 @@ static X509_NAME* subject_to_x509_name(const char *subject, int *nentries)
                                                 MBSTRING_UTF8,
                                                 (const unsigned char*)val,
                                                 -1, -1, 0)) {
-                    spice_debug("warning: failed to add entry %s=%s to X509_NAME",
+                    g_debug("warning: failed to add entry %s=%s to X509_NAME",
                                 key, val);
                     goto fail;
                 }
@@ -377,25 +377,25 @@ static int verify_subject(X509* cert, SpiceOpenSSLVerify* verify)
     int in_entries;
 
     if (!cert) {
-        spice_debug("warning: no cert!");
+        g_debug("warning: no cert!");
         return 0;
     }
 
     cert_subject = X509_get_subject_name(cert);
     if (!cert_subject) {
-        spice_debug("warning: reading certificate subject failed");
+        g_debug("warning: reading certificate subject failed");
         return 0;
     }
 
     in_subject = subject_to_x509_name(verify->subject, &in_entries);
     if (!in_subject) {
-        spice_debug("warning: no in_subject!");
+        g_debug("warning: no in_subject!");
         return 0;
     }
 
     /* Note: this check is redundant with the pre-condition in X509_NAME_cmp */
     if (X509_NAME_entry_count(cert_subject) != in_entries) {
-        spice_debug("subject mismatch: #entries cert=%d, input=%d",
+        g_debug("subject mismatch: #entries cert=%d, input=%d",
             X509_NAME_entry_count(cert_subject), in_entries);
         X509_NAME_free(in_subject);
         return 0;
@@ -404,17 +404,17 @@ static int verify_subject(X509* cert, SpiceOpenSSLVerify* verify)
     ret = X509_NAME_cmp(cert_subject, in_subject);
 
     if (ret == 0) {
-        spice_debug("subjects match");
+        g_debug("subjects match");
     } else {
         char *p;
-        spice_debug("subjects mismatch");
+        g_debug("subjects mismatch");
 
         p = X509_NAME_oneline(cert_subject, NULL, 0);
-        spice_debug("cert_subject: %s", p);
+        g_debug("cert_subject: %s", p);
         free(p);
 
         p = X509_NAME_oneline(in_subject, NULL, 0);
-        spice_debug("in_subject:   %s", p);
+        g_debug("in_subject:   %s", p);
         free(p);
     }
     X509_NAME_free(in_subject);
@@ -440,7 +440,7 @@ static int openssl_verify(int preverify_ok, X509_STORE_CTX *ctx)
     err = X509_STORE_CTX_get_error(ctx);
     if (depth > 0) {
         if (!preverify_ok) {
-            spice_warning("Error in certificate chain verification: %s (num=%d:depth%d:%s)",
+            g_warning("Error in certificate chain verification: %s (num=%d:depth%d:%s)",
                           X509_verify_cert_error_string(err), err, depth, buf);
             v->all_preverify_ok = 0;
 
@@ -451,7 +451,7 @@ static int openssl_verify(int preverify_ok, X509_STORE_CTX *ctx)
                 return 1;
 
             if (err == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN)
-                spice_debug("server certificate not being signed by the provided CA");
+                g_debug("server certificate not being signed by the provided CA");
 
             return 0;
         } else
@@ -460,7 +460,7 @@ static int openssl_verify(int preverify_ok, X509_STORE_CTX *ctx)
 
     /* depth == 0 */
     if (!cert) {
-        spice_debug("failed to get server certificate");
+        g_debug("failed to get server certificate");
         return 0;
     }
 
@@ -475,7 +475,7 @@ static int openssl_verify(int preverify_ok, X509_STORE_CTX *ctx)
     if (!preverify_ok) {
         err = X509_STORE_CTX_get_error(ctx);
         depth = X509_STORE_CTX_get_error_depth(ctx);
-        spice_warning("Error in server certificate verification: %s (num=%d:depth%d:%s)",
+        g_warning("Error in server certificate verification: %s (num=%d:depth%d:%s)",
                       X509_verify_cert_error_string(err), err, depth, buf);
         return 0;
     }
@@ -499,15 +499,15 @@ static int openssl_verify(int preverify_ok, X509_STORE_CTX *ctx)
      * verification failed
      */
     if (failed_verifications & SPICE_SSL_VERIFY_OP_PUBKEY)
-        spice_warning("ssl: pubkey verification failed");
+        g_warning("ssl: pubkey verification failed");
 
     if (failed_verifications & SPICE_SSL_VERIFY_OP_HOSTNAME)
-        spice_warning("ssl: hostname '%s' verification failed", v->hostname);
+        g_warning("ssl: hostname '%s' verification failed", v->hostname);
 
     if (failed_verifications & SPICE_SSL_VERIFY_OP_SUBJECT)
-        spice_warning("ssl: subject '%s' verification failed", v->subject);
+        g_warning("ssl: subject '%s' verification failed", v->subject);
 
-    spice_warning("ssl: verification failed");
+    g_warning("ssl: verification failed");
 
     return 0;
 }
diff --git a/common/sw_canvas.c b/common/sw_canvas.c
index 9dc11ca..f606de2 100644
--- a/common/sw_canvas.c
+++ b/common/sw_canvas.c
@@ -77,7 +77,7 @@ static pixman_image_t *canvas_get_pixman_brush(SwCanvas *canvas,
     case SPICE_BRUSH_TYPE_NONE:
         return NULL;
     default:
-        spice_warn_if_reached();
+        g_warn_if_reached();
         return NULL;
     }
     return NULL;
@@ -489,7 +489,7 @@ static void __scale_image(SpiceCanvas *spice_canvas,
 
     pixman_image_set_transform(src, &transform);
     pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
-    spice_return_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
+    g_return_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
                          scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
     pixman_image_set_filter(src,
                             (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
@@ -556,7 +556,7 @@ static void __scale_image_rop(SpiceCanvas *spice_canvas,
     fsx = ((pixman_fixed_48_16_t) src_width * 65536) / dest_width;
     fsy = ((pixman_fixed_48_16_t) src_height * 65536) / dest_height;
 
-    spice_return_if_fail(spice_pixman_image_get_format(src, &format));
+    g_return_if_fail(spice_pixman_image_get_format(src, &format));
     scaled = pixman_image_create_bits(format,
                                       dest_width,
                                       dest_height,
@@ -572,7 +572,7 @@ static void __scale_image_rop(SpiceCanvas *spice_canvas,
 
     pixman_image_set_transform(src, &transform);
     pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
-    spice_return_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
+    g_return_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
                          scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
     pixman_image_set_filter(src,
                             (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
@@ -773,7 +773,7 @@ static void __blend_scale_image(SpiceCanvas *spice_canvas,
 
     pixman_image_set_transform(src, &transform);
     pixman_image_set_repeat(src, PIXMAN_REPEAT_NONE);
-    spice_return_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
+    g_return_if_fail(scale_mode == SPICE_IMAGE_SCALE_MODE_INTERPOLATE ||
                          scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST);
     pixman_image_set_filter(src,
                             (scale_mode == SPICE_IMAGE_SCALE_MODE_NEAREST) ?
@@ -914,7 +914,7 @@ static void __colorkey_scale_image(SpiceCanvas *spice_canvas,
     fsx = ((pixman_fixed_48_16_t) src_width * 65536) / dest_width;
     fsy = ((pixman_fixed_48_16_t) src_height * 65536) / dest_height;
 
-    spice_return_if_fail(spice_pixman_image_get_format(src, &format));
+    g_return_if_fail(spice_pixman_image_get_format(src, &format));
     scaled = pixman_image_create_bits(format,
                                       dest_width,
                                       dest_height,
@@ -1080,7 +1080,7 @@ static void canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox,
 
         /* Nothing else makes sense for text and we should deprecate it
          * and actually it means OVER really */
-        spice_return_if_fail(text->fore_mode == SPICE_ROPD_OP_PUT);
+        g_return_if_fail(text->fore_mode == SPICE_ROPD_OP_PUT);
 
         pixman_region32_init_rect(&back_region,
                                   text->back_area.left,
@@ -1103,10 +1103,10 @@ static void canvas_draw_text(SpiceCanvas *spice_canvas, SpiceRect *bbox,
     } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A4) {
         depth = 4;
     } else if (str->flags & SPICE_STRING_FLAGS_RASTER_A8) {
-        spice_warning("untested path A8 glyphs");
+        g_warning("untested path A8 glyphs");
         depth = 8;
     } else {
-        spice_warning("unsupported path vector glyphs");
+        g_warning("unsupported path vector glyphs");
         pixman_region32_fini (&dest_region);
         return;
     }
@@ -1149,7 +1149,7 @@ static void canvas_read_bits(SpiceCanvas *spice_canvas, uint8_t *dest,
     uint8_t *dest_end;
     int bpp;
 
-    spice_return_if_fail(canvas && area);
+    g_return_if_fail(canvas && area);
 
     surface = canvas->image;
 
-- 
2.13.0.91.g00982b8dd

_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel




[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]