On Tue, 2018-04-17 at 10:49 +0200, Christophe Fergeau wrote:
> On Mon, Apr 16, 2018 at 08:38:00AM -0400, Frediano Ziglio wrote:
> > >
> > > On Mon, Apr 16, 2018 at 06:58:18AM -0400, Frediano Ziglio wrote:
> > > > Don't like this, lot of structures in this file use "qxl", for coherence
> > > > I would change all or nothing but changing all would mean a lot of changes
> > > > with not much value
> > >
> > > Imo 'red' and 'qxl' are not very good names, I'd prefer to have them
> > > named red_cmd and qxl_cmd. I agree it's quite a few changes though. I
> > > can send an initial patch changing all of these if you prefer.
> > >
> > > Christophe
> > >
> >
> > I would personally keep red and qxl and add a qxl_instance.
>
>
> Fwiw, here is what renaming everything would look like.
> Quite some churn indeed :(
Fwiw, skimming through, the naming would be much better :) I'd try to
get it in despite the churn, not sure how many people have patches
against the code in question...
Cheers,
Lukas
> From 22a4eb242a7b5da0c37a5ebf9aaf8156be423785 Mon Sep 17 00:00:00 2001
> From: Christophe Fergeau <cfergeau@xxxxxxxxxx>
> Date: Tue, 17 Apr 2018 10:36:09 +0200
> Subject: [spice-server] improved arg names in red-parse-qxl
>
> ---
> server/red-parse-qxl.c | 906 +++++++++++++++++++++++++------------------------
> 1 file changed, 455 insertions(+), 451 deletions(-)
>
> diff --git a/server/red-parse-qxl.c b/server/red-parse-qxl.c
> index 7a6805e76..18dcbb2f6 100644
> --- a/server/red-parse-qxl.c
> +++ b/server/red-parse-qxl.c
> @@ -115,7 +115,7 @@ static uint8_t *red_linearize_chunk(RedDataChunk *head, size_t size, bool *free_
>
> static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
> int memslot_id,
> - RedDataChunk *red, QXLDataChunk *qxl)
> + RedDataChunk *red_data_chunk, QXLDataChunk *qxl_data_chunk)
> {
> RedDataChunk *red_prev;
> uint64_t data_size = 0;
> @@ -124,16 +124,16 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
> QXLPHYSICAL next_chunk;
> unsigned num_chunks = 0;
>
> - red->data_size = qxl->data_size;
> - data_size += red->data_size;
> - red->data = qxl->data;
> - red->prev_chunk = red->next_chunk = NULL;
> - if (!memslot_validate_virt(slots, (intptr_t)red->data, memslot_id, red->data_size, group_id)) {
> - red->data = NULL;
> + red_data_chunk->data_size = qxl_data_chunk->data_size;
> + data_size += red_data_chunk->data_size;
> + red_data_chunk->data = qxl_data_chunk->data;
> + red_data_chunk->prev_chunk = red_data_chunk->next_chunk = NULL;
> + if (!memslot_validate_virt(slots, (intptr_t)red_data_chunk->data, memslot_id, red_data_chunk->data_size, group_id)) {
> + red_data_chunk->data = NULL;
> return INVALID_SIZE;
> }
>
> - while ((next_chunk = qxl->next_chunk) != 0) {
> + while ((next_chunk = qxl_data_chunk->next_chunk) != 0) {
> /* somebody is trying to use too much memory using a lot of chunks.
> * Or made a circular list of chunks
> */
> @@ -143,7 +143,7 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
> }
>
> memslot_id = memslot_get_id(slots, next_chunk);
> - qxl = (QXLDataChunk *)memslot_get_virt(slots, next_chunk, sizeof(*qxl),
> + qxl_data_chunk = (QXLDataChunk *)memslot_get_virt(slots, next_chunk, sizeof(*qxl_data_chunk),
> group_id, &error);
> if (error)
> goto error;
> @@ -154,16 +154,16 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
> * All above cases are handled by the check for number
> * of chunks.
> */
> - chunk_data_size = qxl->data_size;
> + chunk_data_size = qxl_data_chunk->data_size;
> if (chunk_data_size == 0)
> continue;
>
> - red_prev = red;
> - red = g_new0(RedDataChunk, 1);
> - red->data_size = chunk_data_size;
> - red->prev_chunk = red_prev;
> - red->data = qxl->data;
> - red_prev->next_chunk = red;
> + red_prev = red_data_chunk;
> + red_data_chunk = g_new0(RedDataChunk, 1);
> + red_data_chunk->data_size = chunk_data_size;
> + red_data_chunk->prev_chunk = red_prev;
> + red_data_chunk->data = qxl_data_chunk->data;
> + red_prev->next_chunk = red_data_chunk;
>
> data_size += chunk_data_size;
> /* this can happen if client is sending nested chunks */
> @@ -171,69 +171,69 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
> spice_warning("too much data inside chunks, avoiding DoS\n");
> goto error;
> }
> - if (!memslot_validate_virt(slots, (intptr_t)red->data, memslot_id, red->data_size, group_id))
> + if (!memslot_validate_virt(slots, (intptr_t)red_data_chunk->data, memslot_id, red_data_chunk->data_size, group_id))
> goto error;
> }
>
> - red->next_chunk = NULL;
> + red_data_chunk->next_chunk = NULL;
> return data_size;
>
> error:
> - while (red->prev_chunk) {
> - red_prev = red->prev_chunk;
> - g_free(red);
> - red = red_prev;
> + while (red_data_chunk->prev_chunk) {
> + red_prev = red_data_chunk->prev_chunk;
> + g_free(red_data_chunk);
> + red_data_chunk = red_prev;
> }
> - red->data_size = 0;
> - red->next_chunk = NULL;
> - red->data = NULL;
> + red_data_chunk->data_size = 0;
> + red_data_chunk->next_chunk = NULL;
> + red_data_chunk->data = NULL;
> return INVALID_SIZE;
> }
>
> static size_t red_get_data_chunks(RedMemSlotInfo *slots, int group_id,
> - RedDataChunk *red, QXLPHYSICAL addr)
> + RedDataChunk *red_data_chunk, QXLPHYSICAL addr)
> {
> - QXLDataChunk *qxl;
> + QXLDataChunk *qxl_data_chunk;
> int error;
> int memslot_id = memslot_get_id(slots, addr);
>
> - qxl = (QXLDataChunk *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_data_chunk = (QXLDataChunk *)memslot_get_virt(slots, addr, sizeof(*qxl_data_chunk), group_id, &error);
> if (error) {
> return INVALID_SIZE;
> }
> - return red_get_data_chunks_ptr(slots, group_id, memslot_id, red, qxl);
> + return red_get_data_chunks_ptr(slots, group_id, memslot_id, red_data_chunk, qxl_data_chunk);
> }
>
> -static void red_put_data_chunks(RedDataChunk *red)
> +static void red_put_data_chunks(RedDataChunk *red_data_chunk)
> {
> RedDataChunk *tmp;
>
> - red = red->next_chunk;
> - while (red) {
> - tmp = red;
> - red = red->next_chunk;
> + red_data_chunk = red_data_chunk->next_chunk;
> + while (red_data_chunk) {
> + tmp = red_data_chunk;
> + red_data_chunk = red_data_chunk->next_chunk;
> g_free(tmp);
> }
> }
>
> -static void red_get_point_ptr(SpicePoint *red, QXLPoint *qxl)
> +static void red_get_point_ptr(SpicePoint *red_point, QXLPoint *qxl_point)
> {
> - red->x = qxl->x;
> - red->y = qxl->y;
> + red_point->x = qxl_point->x;
> + red_point->y = qxl_point->y;
> }
>
> -static void red_get_point16_ptr(SpicePoint16 *red, QXLPoint16 *qxl)
> +static void red_get_point16_ptr(SpicePoint16 *red_point, QXLPoint16 *qxl_point)
> {
> - red->x = qxl->x;
> - red->y = qxl->y;
> + red_point->x = qxl_point->x;
> + red_point->y = qxl_point->y;
> }
>
> -void red_get_rect_ptr(SpiceRect *red, const QXLRect *qxl)
> +void red_get_rect_ptr(SpiceRect *red_rect, const QXLRect *qxl_rect)
> {
> - red->top = qxl->top;
> - red->left = qxl->left;
> - red->bottom = qxl->bottom;
> - red->right = qxl->right;
> + red_rect->top = qxl_rect->top;
> + red_rect->left = qxl_rect->left;
> + red_rect->bottom = qxl_rect->bottom;
> + red_rect->right = qxl_rect->right;
> }
>
> static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
> @@ -244,8 +244,8 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
> SpicePathSeg *seg;
> uint8_t *data;
> bool free_data;
> - QXLPath *qxl;
> - SpicePath *red;
> + QXLPath *qxl_path;
> + SpicePath *red_path;
> size_t size;
> uint64_t mem_size, mem_size2, segment_size;
> int n_segments;
> @@ -253,13 +253,13 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
> uint32_t count;
> int error;
>
> - qxl = (QXLPath *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_path = (QXLPath *)memslot_get_virt(slots, addr, sizeof(*qxl_path), group_id, &error);
> if (error) {
> return NULL;
> }
> size = red_get_data_chunks_ptr(slots, group_id,
> memslot_get_id(slots, addr),
> - &chunks, &qxl->chunk);
> + &chunks, &qxl_path->chunk);
> if (size == INVALID_SIZE) {
> return NULL;
> }
> @@ -267,7 +267,7 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
> red_put_data_chunks(&chunks);
>
> n_segments = 0;
> - mem_size = sizeof(*red);
> + mem_size = sizeof(*red_path);
>
> start = (QXLPathSeg*)data;
> end = (QXLPathSeg*)(data + size);
> @@ -282,16 +282,16 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
> start = (QXLPathSeg*)(&start->points[count]);
> }
>
> - red = g_malloc(mem_size);
> - red->num_segments = n_segments;
> + red_path = g_malloc(mem_size);
> + red_path->num_segments = n_segments;
>
> start = (QXLPathSeg*)data;
> end = (QXLPathSeg*)(data + size);
> - seg = (SpicePathSeg*)&red->segments[n_segments];
> + seg = (SpicePathSeg*)&red_path->segments[n_segments];
> n_segments = 0;
> - mem_size2 = sizeof(*red);
> - while (start+1 < end && n_segments < red->num_segments) {
> - red->segments[n_segments++] = seg;
> + mem_size2 = sizeof(*red_path);
> + while (start+1 < end && n_segments < red_path->num_segments) {
> + red_path->segments[n_segments++] = seg;
> count = start->count;
>
> /* Protect against overflow in size calculations before
> @@ -310,20 +310,20 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
> seg = (SpicePathSeg*)(&seg->points[i]);
> }
> /* Ensure guest didn't tamper with segment count */
> - spice_assert(n_segments == red->num_segments);
> + spice_assert(n_segments == red_path->num_segments);
>
> if (free_data) {
> g_free(data);
> }
> - return red;
> + return red_path;
> }
>
> static SpiceClipRects *red_get_clip_rects(RedMemSlotInfo *slots, int group_id,
> QXLPHYSICAL addr)
> {
> RedDataChunk chunks;
> - QXLClipRects *qxl;
> - SpiceClipRects *red;
> + QXLClipRects *qxl_clip_rects;
> + SpiceClipRects *red_clip_rects;
> QXLRect *start;
> uint8_t *data;
> bool free_data;
> @@ -332,38 +332,38 @@ static SpiceClipRects *red_get_clip_rects(RedMemSlotInfo *slots, int group_id,
> int error;
> uint32_t num_rects;
>
> - qxl = (QXLClipRects *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_clip_rects = (QXLClipRects *)memslot_get_virt(slots, addr, sizeof(*qxl_clip_rects), group_id, &error);
> if (error) {
> return NULL;
> }
> size = red_get_data_chunks_ptr(slots, group_id,
> memslot_get_id(slots, addr),
> - &chunks, &qxl->chunk);
> + &chunks, &qxl_clip_rects->chunk);
> if (size == INVALID_SIZE) {
> return NULL;
> }
> data = red_linearize_chunk(&chunks, size, &free_data);
> red_put_data_chunks(&chunks);
>
> - num_rects = qxl->num_rects;
> + num_rects = qxl_clip_rects->num_rects;
> /* The cast is needed to prevent 32 bit integer overflows.
> * This check is enough as size is limited to 31 bit
> * by red_get_data_chunks_ptr checks.
> */
> spice_assert((uint64_t) num_rects * sizeof(QXLRect) == size);
> SPICE_VERIFY(sizeof(SpiceRect) == sizeof(QXLRect));
> - red = g_malloc(sizeof(*red) + num_rects * sizeof(SpiceRect));
> - red->num_rects = num_rects;
> + red_clip_rects = g_malloc(sizeof(*red_clip_rects) + num_rects * sizeof(SpiceRect));
> + red_clip_rects->num_rects = num_rects;
>
> start = (QXLRect*)data;
> - for (i = 0; i < red->num_rects; i++) {
> - red_get_rect_ptr(red->rects + i, start++);
> + for (i = 0; i < red_clip_rects->num_rects; i++) {
> + red_get_rect_ptr(red_clip_rects->rects + i, start++);
> }
>
> if (free_data) {
> g_free(data);
> }
> - return red;
> + return red_clip_rects;
> }
>
> static SpiceChunks *red_get_image_data_flat(RedMemSlotInfo *slots, int group_id,
> @@ -455,8 +455,8 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
> QXLPHYSICAL addr, uint32_t flags, bool is_mask)
> {
> RedDataChunk chunks;
> - QXLImage *qxl;
> - SpiceImage *red = NULL;
> + QXLImage *qxl_image;
> + SpiceImage *red_image = NULL;
> SpicePalette *rp = NULL;
> uint64_t bitmap_size, size;
> uint8_t qxl_flags;
> @@ -467,44 +467,44 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
> return NULL;
> }
>
> - qxl = (QXLImage *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_image = (QXLImage *)memslot_get_virt(slots, addr, sizeof(*qxl_image), group_id, &error);
> if (error) {
> return NULL;
> }
> - red = g_new0(SpiceImage, 1);
> - red->descriptor.id = qxl->descriptor.id;
> - red->descriptor.type = qxl->descriptor.type;
> - red->descriptor.flags = 0;
> - if (qxl->descriptor.flags & QXL_IMAGE_HIGH_BITS_SET) {
> - red->descriptor.flags |= SPICE_IMAGE_FLAGS_HIGH_BITS_SET;
> + red_image = g_new0(SpiceImage, 1);
> + red_image->descriptor.id = qxl_image->descriptor.id;
> + red_image->descriptor.type = qxl_image->descriptor.type;
> + red_image->descriptor.flags = 0;
> + if (qxl_image->descriptor.flags & QXL_IMAGE_HIGH_BITS_SET) {
> + red_image->descriptor.flags |= SPICE_IMAGE_FLAGS_HIGH_BITS_SET;
> }
> - if (qxl->descriptor.flags & QXL_IMAGE_CACHE) {
> - red->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
> + if (qxl_image->descriptor.flags & QXL_IMAGE_CACHE) {
> + red_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
> }
> - red->descriptor.width = qxl->descriptor.width;
> - red->descriptor.height = qxl->descriptor.height;
> + red_image->descriptor.width = qxl_image->descriptor.width;
> + red_image->descriptor.height = qxl_image->descriptor.height;
>
> - switch (red->descriptor.type) {
> + switch (red_image->descriptor.type) {
> case SPICE_IMAGE_TYPE_BITMAP:
> - red->u.bitmap.format = qxl->bitmap.format;
> - red->u.bitmap.x = qxl->bitmap.x;
> - red->u.bitmap.y = qxl->bitmap.y;
> - red->u.bitmap.stride = qxl->bitmap.stride;
> - palette = qxl->bitmap.palette;
> - if (!bitmap_fmt_is_rgb(red->u.bitmap.format) && !palette && !is_mask) {
> + red_image->u.bitmap.format = qxl_image->bitmap.format;
> + red_image->u.bitmap.x = qxl_image->bitmap.x;
> + red_image->u.bitmap.y = qxl_image->bitmap.y;
> + red_image->u.bitmap.stride = qxl_image->bitmap.stride;
> + palette = qxl_image->bitmap.palette;
> + if (!bitmap_fmt_is_rgb(red_image->u.bitmap.format) && !palette && !is_mask) {
> spice_warning("guest error: missing palette on bitmap format=%d\n",
> - red->u.bitmap.format);
> + red_image->u.bitmap.format);
> goto error;
> }
> - if (red->u.bitmap.x == 0 || red->u.bitmap.y == 0) {
> + if (red_image->u.bitmap.x == 0 || red_image->u.bitmap.y == 0) {
> spice_warning("guest error: zero area bitmap\n");
> goto error;
> }
> - qxl_flags = qxl->bitmap.flags;
> + qxl_flags = qxl_image->bitmap.flags;
> if (qxl_flags & QXL_BITMAP_TOP_DOWN) {
> - red->u.bitmap.flags = SPICE_BITMAP_FLAGS_TOP_DOWN;
> + red_image->u.bitmap.flags = SPICE_BITMAP_FLAGS_TOP_DOWN;
> }
> - if (!bitmap_consistent(&red->u.bitmap)) {
> + if (!bitmap_consistent(&red_image->u.bitmap)) {
> goto error;
> }
> if (palette) {
> @@ -533,235 +533,235 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
> rp->ents[i] = qp->ents[i];
> }
> }
> - red->u.bitmap.palette = rp;
> - red->u.bitmap.palette_id = rp->unique;
> + red_image->u.bitmap.palette = rp;
> + red_image->u.bitmap.palette_id = rp->unique;
> }
> - bitmap_size = (uint64_t) red->u.bitmap.y * red->u.bitmap.stride;
> + bitmap_size = (uint64_t) red_image->u.bitmap.y * red_image->u.bitmap.stride;
> if (bitmap_size > MAX_DATA_CHUNK) {
> goto error;
> }
> if (qxl_flags & QXL_BITMAP_DIRECT) {
> - red->u.bitmap.data = red_get_image_data_flat(slots, group_id,
> - qxl->bitmap.data,
> + red_image->u.bitmap.data = red_get_image_data_flat(slots, group_id,
> + qxl_image->bitmap.data,
> bitmap_size);
> } else {
> size = red_get_data_chunks(slots, group_id,
> - &chunks, qxl->bitmap.data);
> + &chunks, qxl_image->bitmap.data);
> if (size == INVALID_SIZE || size != bitmap_size) {
> red_put_data_chunks(&chunks);
> goto error;
> }
> - red->u.bitmap.data = red_get_image_data_chunked(slots, group_id,
> + red_image->u.bitmap.data = red_get_image_data_chunked(slots, group_id,
> &chunks);
> red_put_data_chunks(&chunks);
> }
> if (qxl_flags & QXL_BITMAP_UNSTABLE) {
> - red->u.bitmap.data->flags |= SPICE_CHUNKS_FLAGS_UNSTABLE;
> + red_image->u.bitmap.data->flags |= SPICE_CHUNKS_FLAGS_UNSTABLE;
> }
> break;
> case SPICE_IMAGE_TYPE_SURFACE:
> - red->u.surface.surface_id = qxl->surface_image.surface_id;
> + red_image->u.surface.surface_id = qxl_image->surface_image.surface_id;
> break;
> case SPICE_IMAGE_TYPE_QUIC:
> - red->u.quic.data_size = qxl->quic.data_size;
> + red_image->u.quic.data_size = qxl_image->quic.data_size;
> size = red_get_data_chunks_ptr(slots, group_id,
> memslot_get_id(slots, addr),
> - &chunks, (QXLDataChunk *)qxl->quic.data);
> - if (size == INVALID_SIZE || size != red->u.quic.data_size) {
> + &chunks, (QXLDataChunk *)qxl_image->quic.data);
> + if (size == INVALID_SIZE || size != red_image->u.quic.data_size) {
> red_put_data_chunks(&chunks);
> goto error;
> }
> - red->u.quic.data = red_get_image_data_chunked(slots, group_id,
> + red_image->u.quic.data = red_get_image_data_chunked(slots, group_id,
> &chunks);
> red_put_data_chunks(&chunks);
> break;
> default:
> - spice_warning("unknown type %d", red->descriptor.type);
> + spice_warning("unknown type %d", red_image->descriptor.type);
> goto error;
> }
> - return red;
> + return red_image;
> error:
> - g_free(red);
> + g_free(red_image);
> g_free(rp);
> return NULL;
> }
>
> -static void red_put_image(SpiceImage *red)
> +static void red_put_image(SpiceImage *red_image)
> {
> - if (red == NULL)
> + if (red_image == NULL)
> return;
>
> - switch (red->descriptor.type) {
> + switch (red_image->descriptor.type) {
> case SPICE_IMAGE_TYPE_BITMAP:
> - g_free(red->u.bitmap.palette);
> - spice_chunks_destroy(red->u.bitmap.data);
> + g_free(red_image->u.bitmap.palette);
> + spice_chunks_destroy(red_image->u.bitmap.data);
> break;
> case SPICE_IMAGE_TYPE_QUIC:
> - spice_chunks_destroy(red->u.quic.data);
> + spice_chunks_destroy(red_image->u.quic.data);
> break;
> }
> - g_free(red);
> + g_free(red_image);
> }
>
> static void red_get_brush_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceBrush *red, QXLBrush *qxl, uint32_t flags)
> + SpiceBrush *red_brush, QXLBrush *qxl_brush, uint32_t flags)
> {
> - red->type = qxl->type;
> - switch (red->type) {
> + red_brush->type = qxl_brush->type;
> + switch (red_brush->type) {
> case SPICE_BRUSH_TYPE_SOLID:
> if (flags & QXL_COMMAND_FLAG_COMPAT_16BPP) {
> - red->u.color = color_16_to_32(qxl->u.color);
> + red_brush->u.color = color_16_to_32(qxl_brush->u.color);
> } else {
> - red->u.color = qxl->u.color;
> + red_brush->u.color = qxl_brush->u.color;
> }
> break;
> case SPICE_BRUSH_TYPE_PATTERN:
> - red->u.pattern.pat = red_get_image(slots, group_id, qxl->u.pattern.pat, flags, false);
> - red_get_point_ptr(&red->u.pattern.pos, &qxl->u.pattern.pos);
> + red_brush->u.pattern.pat = red_get_image(slots, group_id, qxl_brush->u.pattern.pat, flags, false);
> + red_get_point_ptr(&red_brush->u.pattern.pos, &qxl_brush->u.pattern.pos);
> break;
> }
> }
>
> -static void red_put_brush(SpiceBrush *red)
> +static void red_put_brush(SpiceBrush *red_brush)
> {
> - switch (red->type) {
> + switch (red_brush->type) {
> case SPICE_BRUSH_TYPE_PATTERN:
> - red_put_image(red->u.pattern.pat);
> + red_put_image(red_brush->u.pattern.pat);
> break;
> }
> }
>
> static void red_get_qmask_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceQMask *red, QXLQMask *qxl, uint32_t flags)
> + SpiceQMask *red_qmask, QXLQMask *qxl_qmask, uint32_t flags)
> {
> - red->flags = qxl->flags;
> - red_get_point_ptr(&red->pos, &qxl->pos);
> - red->bitmap = red_get_image(slots, group_id, qxl->bitmap, flags, true);
> + red_qmask->flags = qxl_qmask->flags;
> + red_get_point_ptr(&red_qmask->pos, &qxl_qmask->pos);
> + red_qmask->bitmap = red_get_image(slots, group_id, qxl_qmask->bitmap, flags, true);
> }
>
> -static void red_put_qmask(SpiceQMask *red)
> +static void red_put_qmask(SpiceQMask *red_qmask)
> {
> - red_put_image(red->bitmap);
> + red_put_image(red_qmask->bitmap);
> }
>
> static void red_get_fill_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceFill *red, QXLFill *qxl, uint32_t flags)
> + SpiceFill *red_fill, QXLFill *qxl_fill, uint32_t flags)
> {
> - red_get_brush_ptr(slots, group_id, &red->brush, &qxl->brush, flags);
> - red->rop_descriptor = qxl->rop_descriptor;
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_get_brush_ptr(slots, group_id, &red_fill->brush, &qxl_fill->brush, flags);
> + red_fill->rop_descriptor = qxl_fill->rop_descriptor;
> + red_get_qmask_ptr(slots, group_id, &red_fill->mask, &qxl_fill->mask, flags);
> }
>
> -static void red_put_fill(SpiceFill *red)
> +static void red_put_fill(SpiceFill *red_fill)
> {
> - red_put_brush(&red->brush);
> - red_put_qmask(&red->mask);
> + red_put_brush(&red_fill->brush);
> + red_put_qmask(&red_fill->mask);
> }
>
> static void red_get_opaque_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceOpaque *red, QXLOpaque *qxl, uint32_t flags)
> + SpiceOpaque *red_opaque, QXLOpaque *qxl_opaque, uint32_t flags)
> {
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src_bitmap, flags, false);
> - red_get_rect_ptr(&red->src_area, &qxl->src_area);
> - red_get_brush_ptr(slots, group_id, &red->brush, &qxl->brush, flags);
> - red->rop_descriptor = qxl->rop_descriptor;
> - red->scale_mode = qxl->scale_mode;
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_opaque->src_bitmap = red_get_image(slots, group_id, qxl_opaque->src_bitmap, flags, false);
> + red_get_rect_ptr(&red_opaque->src_area, &qxl_opaque->src_area);
> + red_get_brush_ptr(slots, group_id, &red_opaque->brush, &qxl_opaque->brush, flags);
> + red_opaque->rop_descriptor = qxl_opaque->rop_descriptor;
> + red_opaque->scale_mode = qxl_opaque->scale_mode;
> + red_get_qmask_ptr(slots, group_id, &red_opaque->mask, &qxl_opaque->mask, flags);
> }
>
> -static void red_put_opaque(SpiceOpaque *red)
> +static void red_put_opaque(SpiceOpaque *red_opaque)
> {
> - red_put_image(red->src_bitmap);
> - red_put_brush(&red->brush);
> - red_put_qmask(&red->mask);
> + red_put_image(red_opaque->src_bitmap);
> + red_put_brush(&red_opaque->brush);
> + red_put_qmask(&red_opaque->mask);
> }
>
> static bool red_get_copy_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceCopy *red, QXLCopy *qxl, uint32_t flags)
> + SpiceCopy *red_copy, QXLCopy *qxl_copy, uint32_t flags)
> {
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src_bitmap, flags, false);
> - if (!red->src_bitmap) {
> + red_copy->src_bitmap = red_get_image(slots, group_id, qxl_copy->src_bitmap, flags, false);
> + if (!red_copy->src_bitmap) {
> return false;
> }
> - red_get_rect_ptr(&red->src_area, &qxl->src_area);
> + red_get_rect_ptr(&red_copy->src_area, &qxl_copy->src_area);
> /* The source area should not extend outside the source bitmap or have
> * swapped coordinates.
> */
> - if (red->src_area.left < 0 ||
> - red->src_area.left > red->src_area.right ||
> - red->src_area.top < 0 ||
> - red->src_area.top > red->src_area.bottom) {
> + if (red_copy->src_area.left < 0 ||
> + red_copy->src_area.left > red_copy->src_area.right ||
> + red_copy->src_area.top < 0 ||
> + red_copy->src_area.top > red_copy->src_area.bottom) {
> return false;
> }
> - if (red->src_bitmap->descriptor.type == SPICE_IMAGE_TYPE_BITMAP &&
> - (red->src_area.right > red->src_bitmap->u.bitmap.x ||
> - red->src_area.bottom > red->src_bitmap->u.bitmap.y)) {
> + if (red_copy->src_bitmap->descriptor.type == SPICE_IMAGE_TYPE_BITMAP &&
> + (red_copy->src_area.right > red_copy->src_bitmap->u.bitmap.x ||
> + red_copy->src_area.bottom > red_copy->src_bitmap->u.bitmap.y)) {
> return false;
> }
> - red->rop_descriptor = qxl->rop_descriptor;
> - red->scale_mode = qxl->scale_mode;
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_copy->rop_descriptor = qxl_copy->rop_descriptor;
> + red_copy->scale_mode = qxl_copy->scale_mode;
> + red_get_qmask_ptr(slots, group_id, &red_copy->mask, &qxl_copy->mask, flags);
> return true;
> }
>
> -static void red_put_copy(SpiceCopy *red)
> +static void red_put_copy(SpiceCopy *red_copy)
> {
> - red_put_image(red->src_bitmap);
> - red_put_qmask(&red->mask);
> + red_put_image(red_copy->src_bitmap);
> + red_put_qmask(&red_copy->mask);
> }
>
> // these types are really the same thing
> #define red_get_blend_ptr red_get_copy_ptr
>
> -static void red_put_blend(SpiceBlend *red)
> +static void red_put_blend(SpiceBlend *red_blend)
> {
> - red_put_image(red->src_bitmap);
> - red_put_qmask(&red->mask);
> + red_put_image(red_blend->src_bitmap);
> + red_put_qmask(&red_blend->mask);
> }
>
> static void red_get_transparent_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceTransparent *red, QXLTransparent *qxl,
> + SpiceTransparent *red_transparent, QXLTransparent *qxl_transparent,
> uint32_t flags)
> {
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src_bitmap, flags, false);
> - red_get_rect_ptr(&red->src_area, &qxl->src_area);
> - red->src_color = qxl->src_color;
> - red->true_color = qxl->true_color;
> + red_transparent->src_bitmap = red_get_image(slots, group_id, qxl_transparent->src_bitmap, flags, false);
> + red_get_rect_ptr(&red_transparent->src_area, &qxl_transparent->src_area);
> + red_transparent->src_color = qxl_transparent->src_color;
> + red_transparent->true_color = qxl_transparent->true_color;
> }
>
> -static void red_put_transparent(SpiceTransparent *red)
> +static void red_put_transparent(SpiceTransparent *red_transparent)
> {
> - red_put_image(red->src_bitmap);
> + red_put_image(red_transparent->src_bitmap);
> }
>
> static void red_get_alpha_blend_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceAlphaBlend *red, QXLAlphaBlend *qxl,
> + SpiceAlphaBlend *red_blend, QXLAlphaBlend *qxl_blend,
> uint32_t flags)
> {
> - red->alpha_flags = qxl->alpha_flags;
> - red->alpha = qxl->alpha;
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src_bitmap, flags, false);
> - red_get_rect_ptr(&red->src_area, &qxl->src_area);
> + red_blend->alpha_flags = qxl_blend->alpha_flags;
> + red_blend->alpha = qxl_blend->alpha;
> + red_blend->src_bitmap = red_get_image(slots, group_id, qxl_blend->src_bitmap, flags, false);
> + red_get_rect_ptr(&red_blend->src_area, &qxl_blend->src_area);
> }
>
> static void red_get_alpha_blend_ptr_compat(RedMemSlotInfo *slots, int group_id,
> - SpiceAlphaBlend *red, QXLCompatAlphaBlend *qxl,
> + SpiceAlphaBlend *red_blend, QXLCompatAlphaBlend *qxl_blend,
> uint32_t flags)
> {
> - red->alpha = qxl->alpha;
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src_bitmap, flags, false);
> - red_get_rect_ptr(&red->src_area, &qxl->src_area);
> + red_blend->alpha = qxl_blend->alpha;
> + red_blend->src_bitmap = red_get_image(slots, group_id, qxl_blend->src_bitmap, flags, false);
> + red_get_rect_ptr(&red_blend->src_area, &qxl_blend->src_area);
> }
>
> -static void red_put_alpha_blend(SpiceAlphaBlend *red)
> +static void red_put_alpha_blend(SpiceAlphaBlend *red_blend)
> {
> - red_put_image(red->src_bitmap);
> + red_put_image(red_blend->src_bitmap);
> }
>
> static bool get_transform(RedMemSlotInfo *slots,
> int group_id,
> QXLPHYSICAL qxl_transform,
> - SpiceTransform *dst_transform)
> + SpiceTransform *red_transform)
> {
> const uint32_t *t = NULL;
> int error;
> @@ -769,103 +769,104 @@ static bool get_transform(RedMemSlotInfo *slots,
> if (qxl_transform == 0)
> return false;
>
> - t = (uint32_t *)memslot_get_virt(slots, qxl_transform, sizeof(*dst_transform), group_id, &error);
> + t = (uint32_t *)memslot_get_virt(slots, qxl_transform, sizeof(*red_transform), group_id, &error);
>
> if (!t || error)
> return false;
>
> - memcpy(dst_transform, t, sizeof(*dst_transform));
> + memcpy(red_transform, t, sizeof(*red_transform));
> return true;
> }
>
> static void red_get_composite_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceComposite *red, QXLComposite *qxl, uint32_t flags)
> + SpiceComposite *red_composite, QXLComposite *qxl_composite,
> + uint32_t flags)
> {
> - red->flags = qxl->flags;
> + red_composite->flags = qxl_composite->flags;
>
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src, flags, false);
> - if (get_transform(slots, group_id, qxl->src_transform, &red->src_transform))
> - red->flags |= SPICE_COMPOSITE_HAS_SRC_TRANSFORM;
> + red_composite->src_bitmap = red_get_image(slots, group_id, qxl_composite->src, flags, false);
> + if (get_transform(slots, group_id, qxl_composite->src_transform, &red_composite->src_transform))
> + red_composite->flags |= SPICE_COMPOSITE_HAS_SRC_TRANSFORM;
>
> - if (qxl->mask) {
> - red->mask_bitmap = red_get_image(slots, group_id, qxl->mask, flags, false);
> - red->flags |= SPICE_COMPOSITE_HAS_MASK;
> - if (get_transform(slots, group_id, qxl->mask_transform, &red->mask_transform))
> - red->flags |= SPICE_COMPOSITE_HAS_MASK_TRANSFORM;
> + if (qxl_composite->mask) {
> + red_composite->mask_bitmap = red_get_image(slots, group_id, qxl_composite->mask, flags, false);
> + red_composite->flags |= SPICE_COMPOSITE_HAS_MASK;
> + if (get_transform(slots, group_id, qxl_composite->mask_transform, &red_composite->mask_transform))
> + red_composite->flags |= SPICE_COMPOSITE_HAS_MASK_TRANSFORM;
> } else {
> - red->mask_bitmap = NULL;
> + red_composite->mask_bitmap = NULL;
> }
> - red->src_origin.x = qxl->src_origin.x;
> - red->src_origin.y = qxl->src_origin.y;
> - red->mask_origin.x = qxl->mask_origin.x;
> - red->mask_origin.y = qxl->mask_origin.y;
> + red_composite->src_origin.x = qxl_composite->src_origin.x;
> + red_composite->src_origin.y = qxl_composite->src_origin.y;
> + red_composite->mask_origin.x = qxl_composite->mask_origin.x;
> + red_composite->mask_origin.y = qxl_composite->mask_origin.y;
> }
>
> -static void red_put_composite(SpiceComposite *red)
> +static void red_put_composite(SpiceComposite *red_composite)
> {
> - red_put_image(red->src_bitmap);
> - if (red->mask_bitmap)
> - red_put_image(red->mask_bitmap);
> + red_put_image(red_composite->src_bitmap);
> + if (red_composite->mask_bitmap)
> + red_put_image(red_composite->mask_bitmap);
> }
>
> static void red_get_rop3_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceRop3 *red, QXLRop3 *qxl, uint32_t flags)
> + SpiceRop3 *red_rop3, QXLRop3 *qxl_rop3, uint32_t flags)
> {
> - red->src_bitmap = red_get_image(slots, group_id, qxl->src_bitmap, flags, false);
> - red_get_rect_ptr(&red->src_area, &qxl->src_area);
> - red_get_brush_ptr(slots, group_id, &red->brush, &qxl->brush, flags);
> - red->rop3 = qxl->rop3;
> - red->scale_mode = qxl->scale_mode;
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_rop3->src_bitmap = red_get_image(slots, group_id, qxl_rop3->src_bitmap, flags, false);
> + red_get_rect_ptr(&red_rop3->src_area, &qxl_rop3->src_area);
> + red_get_brush_ptr(slots, group_id, &red_rop3->brush, &qxl_rop3->brush, flags);
> + red_rop3->rop3 = qxl_rop3->rop3;
> + red_rop3->scale_mode = qxl_rop3->scale_mode;
> + red_get_qmask_ptr(slots, group_id, &red_rop3->mask, &qxl_rop3->mask, flags);
> }
>
> -static void red_put_rop3(SpiceRop3 *red)
> +static void red_put_rop3(SpiceRop3 *red_rop3)
> {
> - red_put_image(red->src_bitmap);
> - red_put_brush(&red->brush);
> - red_put_qmask(&red->mask);
> + red_put_image(red_rop3->src_bitmap);
> + red_put_brush(&red_rop3->brush);
> + red_put_qmask(&red_rop3->mask);
> }
>
> static bool red_get_stroke_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceStroke *red, QXLStroke *qxl, uint32_t flags)
> + SpiceStroke *red_stroke, QXLStroke *qxl_stroke, uint32_t flags)
> {
> int error;
>
> - red->path = red_get_path(slots, group_id, qxl->path);
> - if (!red->path) {
> + red_stroke->path = red_get_path(slots, group_id, qxl_stroke->path);
> + if (!red_stroke->path) {
> return false;
> }
> - red->attr.flags = qxl->attr.flags;
> - if (red->attr.flags & SPICE_LINE_FLAGS_STYLED) {
> + red_stroke->attr.flags = qxl_stroke->attr.flags;
> + if (red_stroke->attr.flags & SPICE_LINE_FLAGS_STYLED) {
> int style_nseg;
> uint8_t *buf;
>
> - style_nseg = qxl->attr.style_nseg;
> - red->attr.style = g_malloc_n(style_nseg, sizeof(SPICE_FIXED28_4));
> - red->attr.style_nseg = style_nseg;
> - spice_assert(qxl->attr.style);
> - buf = (uint8_t *)memslot_get_virt(slots, qxl->attr.style,
> + style_nseg = qxl_stroke->attr.style_nseg;
> + red_stroke->attr.style = g_malloc_n(style_nseg, sizeof(SPICE_FIXED28_4));
> + red_stroke->attr.style_nseg = style_nseg;
> + spice_assert(qxl_stroke->attr.style);
> + buf = (uint8_t *)memslot_get_virt(slots, qxl_stroke->attr.style,
> style_nseg * sizeof(QXLFIXED), group_id, &error);
> if (error) {
> return false;
> }
> - memcpy(red->attr.style, buf, style_nseg * sizeof(QXLFIXED));
> + memcpy(red_stroke->attr.style, buf, style_nseg * sizeof(QXLFIXED));
> } else {
> - red->attr.style_nseg = 0;
> - red->attr.style = NULL;
> + red_stroke->attr.style_nseg = 0;
> + red_stroke->attr.style = NULL;
> }
> - red_get_brush_ptr(slots, group_id, &red->brush, &qxl->brush, flags);
> - red->fore_mode = qxl->fore_mode;
> - red->back_mode = qxl->back_mode;
> + red_get_brush_ptr(slots, group_id, &red_stroke->brush, &qxl_stroke->brush, flags);
> + red_stroke->fore_mode = qxl_stroke->fore_mode;
> + red_stroke->back_mode = qxl_stroke->back_mode;
> return true;
> }
>
> -static void red_put_stroke(SpiceStroke *red)
> +static void red_put_stroke(SpiceStroke *red_stroke)
> {
> - red_put_brush(&red->brush);
> - g_free(red->path);
> - if (red->attr.flags & SPICE_LINE_FLAGS_STYLED) {
> - g_free(red->attr.style);
> + red_put_brush(&red_stroke->brush);
> + g_free(red_stroke->path);
> + if (red_stroke->attr.flags & SPICE_LINE_FLAGS_STYLED) {
> + g_free(red_stroke->attr.style);
> }
> }
>
> @@ -873,9 +874,9 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
> QXLPHYSICAL addr)
> {
> RedDataChunk chunks;
> - QXLString *qxl;
> + QXLString *qxl_string;
> QXLRasterGlyph *start, *end;
> - SpiceString *red;
> + SpiceString *red_string;
> SpiceRasterGlyph *glyph;
> uint8_t *data;
> bool free_data;
> @@ -886,22 +887,22 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
> int error;
> uint16_t qxl_flags, qxl_length;
>
> - qxl = (QXLString *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_string = (QXLString *)memslot_get_virt(slots, addr, sizeof(*qxl_string), group_id, &error);
> if (error) {
> return NULL;
> }
> chunk_size = red_get_data_chunks_ptr(slots, group_id,
> memslot_get_id(slots, addr),
> - &chunks, &qxl->chunk);
> + &chunks, &qxl_string->chunk);
> if (chunk_size == INVALID_SIZE) {
> return NULL;
> }
> data = red_linearize_chunk(&chunks, chunk_size, &free_data);
> red_put_data_chunks(&chunks);
>
> - qxl_size = qxl->data_size;
> - qxl_flags = qxl->flags;
> - qxl_length = qxl->length;
> + qxl_size = qxl_string->data_size;
> + qxl_flags = qxl_string->flags;
> + qxl_length = qxl_string->length;
> spice_assert(chunk_size == qxl_size);
>
> if (qxl_flags & SPICE_STRING_FLAGS_RASTER_A1) {
> @@ -932,16 +933,16 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
> spice_assert(start <= end);
> spice_assert(glyphs == qxl_length);
>
> - red = g_malloc(red_size);
> - red->length = qxl_length;
> - red->flags = qxl_flags;
> + red_string = g_malloc(red_size);
> + red_string->length = qxl_length;
> + red_string->flags = qxl_flags;
>
> start = (QXLRasterGlyph*)data;
> end = (QXLRasterGlyph*)(data + chunk_size);
> - glyph = (SpiceRasterGlyph *)&red->glyphs[red->length];
> - for (i = 0; i < red->length; i++) {
> + glyph = (SpiceRasterGlyph *)&red_string->glyphs[red_string->length];
> + for (i = 0; i < red_string->length; i++) {
> spice_assert((QXLRasterGlyph*)(&start->data[0]) <= end);
> - red->glyphs[i] = glyph;
> + red_string->glyphs[i] = glyph;
> glyph->width = start->width;
> glyph->height = start->height;
> red_get_point_ptr(&glyph->render_pos, &start->render_pos);
> @@ -959,335 +960,337 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
> if (free_data) {
> g_free(data);
> }
> - return red;
> + return red_string;
> }
>
> static void red_get_text_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceText *red, QXLText *qxl, uint32_t flags)
> + SpiceText *red_text, QXLText *qxl_text, uint32_t flags)
> {
> - red->str = red_get_string(slots, group_id, qxl->str);
> - red_get_rect_ptr(&red->back_area, &qxl->back_area);
> - red_get_brush_ptr(slots, group_id, &red->fore_brush, &qxl->fore_brush, flags);
> - red_get_brush_ptr(slots, group_id, &red->back_brush, &qxl->back_brush, flags);
> - red->fore_mode = qxl->fore_mode;
> - red->back_mode = qxl->back_mode;
> + red_text->str = red_get_string(slots, group_id, qxl_text->str);
> + red_get_rect_ptr(&red_text->back_area, &qxl_text->back_area);
> + red_get_brush_ptr(slots, group_id, &red_text->fore_brush, &qxl_text->fore_brush, flags);
> + red_get_brush_ptr(slots, group_id, &red_text->back_brush, &qxl_text->back_brush, flags);
> + red_text->fore_mode = qxl_text->fore_mode;
> + red_text->back_mode = qxl_text->back_mode;
> }
>
> -static void red_put_text_ptr(SpiceText *red)
> +static void red_put_text_ptr(SpiceText *red_text)
> {
> - g_free(red->str);
> - red_put_brush(&red->fore_brush);
> - red_put_brush(&red->back_brush);
> + g_free(red_text->str);
> + red_put_brush(&red_text->fore_brush);
> + red_put_brush(&red_text->back_brush);
> }
>
> static void red_get_whiteness_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceWhiteness *red, QXLWhiteness *qxl, uint32_t flags)
> + SpiceWhiteness *red_whiteness, QXLWhiteness *qxl_whiteness,
> + uint32_t flags)
> {
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_get_qmask_ptr(slots, group_id, &red_whiteness->mask, &qxl_whiteness->mask, flags);
> }
>
> -static void red_put_whiteness(SpiceWhiteness *red)
> +static void red_put_whiteness(SpiceWhiteness *red_whiteness)
> {
> - red_put_qmask(&red->mask);
> + red_put_qmask(&red_whiteness->mask);
> }
>
> static void red_get_blackness_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceBlackness *red, QXLBlackness *qxl, uint32_t flags)
> + SpiceBlackness *red_blackness, QXLBlackness *qxl_blackness,
> + uint32_t flags)
> {
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_get_qmask_ptr(slots, group_id, &red_blackness->mask, &qxl_blackness->mask, flags);
> }
>
> -static void red_put_blackness(SpiceBlackness *red)
> +static void red_put_blackness(SpiceBlackness *red_blackness)
> {
> - red_put_qmask(&red->mask);
> + red_put_qmask(&red_blackness->mask);
> }
>
> static void red_get_invers_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceInvers *red, QXLInvers *qxl, uint32_t flags)
> + SpiceInvers *red_invers, QXLInvers *qxl_invers, uint32_t flags)
> {
> - red_get_qmask_ptr(slots, group_id, &red->mask, &qxl->mask, flags);
> + red_get_qmask_ptr(slots, group_id, &red_invers->mask, &qxl_invers->mask, flags);
> }
>
> -static void red_put_invers(SpiceInvers *red)
> +static void red_put_invers(SpiceInvers *red_invers)
> {
> - red_put_qmask(&red->mask);
> + red_put_qmask(&red_invers->mask);
> }
>
> static void red_get_clip_ptr(RedMemSlotInfo *slots, int group_id,
> - SpiceClip *red, QXLClip *qxl)
> + SpiceClip *red_clip, QXLClip *qxl_clip)
> {
> - red->type = qxl->type;
> - switch (red->type) {
> + red_clip->type = qxl_clip->type;
> + switch (red_clip->type) {
> case SPICE_CLIP_TYPE_RECTS:
> - red->rects = red_get_clip_rects(slots, group_id, qxl->data);
> + red_clip->rects = red_get_clip_rects(slots, group_id, qxl_clip->data);
> break;
> }
> }
>
> -static void red_put_clip(SpiceClip *red)
> +static void red_put_clip(SpiceClip *red_clip)
> {
> - switch (red->type) {
> + switch (red_clip->type) {
> case SPICE_CLIP_TYPE_RECTS:
> - g_free(red->rects);
> + g_free(red_clip->rects);
> break;
> }
> }
>
> static bool red_get_native_drawable(RedMemSlotInfo *slots, int group_id,
> - RedDrawable *red, QXLPHYSICAL addr, uint32_t flags)
> + RedDrawable *red_drawable, QXLPHYSICAL addr, uint32_t flags)
> {
> - QXLDrawable *qxl;
> + QXLDrawable *qxl_drawable;
> int i;
> int error = 0;
>
> - qxl = (QXLDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_drawable = (QXLDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl_drawable), group_id, &error);
> if (error) {
> return false;
> }
> - red->release_info_ext.info = &qxl->release_info;
> - red->release_info_ext.group_id = group_id;
> + red_drawable->release_info_ext.info = &qxl_drawable->release_info;
> + red_drawable->release_info_ext.group_id = group_id;
>
> - red_get_rect_ptr(&red->bbox, &qxl->bbox);
> - red_get_clip_ptr(slots, group_id, &red->clip, &qxl->clip);
> - red->effect = qxl->effect;
> - red->mm_time = qxl->mm_time;
> - red->self_bitmap = qxl->self_bitmap;
> - red_get_rect_ptr(&red->self_bitmap_area, &qxl->self_bitmap_area);
> - red->surface_id = qxl->surface_id;
> + red_get_rect_ptr(&red_drawable->bbox, &qxl_drawable->bbox);
> + red_get_clip_ptr(slots, group_id, &red_drawable->clip, &qxl_drawable->clip);
> + red_drawable->effect = qxl_drawable->effect;
> + red_drawable->mm_time = qxl_drawable->mm_time;
> + red_drawable->self_bitmap = qxl_drawable->self_bitmap;
> + red_get_rect_ptr(&red_drawable->self_bitmap_area, &qxl_drawable->self_bitmap_area);
> + red_drawable->surface_id = qxl_drawable->surface_id;
>
> for (i = 0; i < 3; i++) {
> - red->surface_deps[i] = qxl->surfaces_dest[i];
> - red_get_rect_ptr(&red->surfaces_rects[i], &qxl->surfaces_rects[i]);
> + red_drawable->surface_deps[i] = qxl_drawable->surfaces_dest[i];
> + red_get_rect_ptr(&red_drawable->surfaces_rects[i], &qxl_drawable->surfaces_rects[i]);
> }
>
> - red->type = qxl->type;
> - switch (red->type) {
> + red_drawable->type = qxl_drawable->type;
> + switch (red_drawable->type) {
> case QXL_DRAW_ALPHA_BLEND:
> red_get_alpha_blend_ptr(slots, group_id,
> - &red->u.alpha_blend, &qxl->u.alpha_blend, flags);
> + &red_drawable->u.alpha_blend, &qxl_drawable->u.alpha_blend, flags);
> break;
> case QXL_DRAW_BLACKNESS:
> red_get_blackness_ptr(slots, group_id,
> - &red->u.blackness, &qxl->u.blackness, flags);
> + &red_drawable->u.blackness, &qxl_drawable->u.blackness, flags);
> break;
> case QXL_DRAW_BLEND:
> - return red_get_blend_ptr(slots, group_id, &red->u.blend, &qxl->u.blend, flags);
> + return red_get_blend_ptr(slots, group_id, &red_drawable->u.blend, &qxl_drawable->u.blend, flags);
> case QXL_DRAW_COPY:
> - return red_get_copy_ptr(slots, group_id, &red->u.copy, &qxl->u.copy, flags);
> + return red_get_copy_ptr(slots, group_id, &red_drawable->u.copy, &qxl_drawable->u.copy, flags);
> case QXL_COPY_BITS:
> - red_get_point_ptr(&red->u.copy_bits.src_pos, &qxl->u.copy_bits.src_pos);
> + red_get_point_ptr(&red_drawable->u.copy_bits.src_pos, &qxl_drawable->u.copy_bits.src_pos);
> break;
> case QXL_DRAW_FILL:
> - red_get_fill_ptr(slots, group_id, &red->u.fill, &qxl->u.fill, flags);
> + red_get_fill_ptr(slots, group_id, &red_drawable->u.fill, &qxl_drawable->u.fill, flags);
> break;
> case QXL_DRAW_OPAQUE:
> - red_get_opaque_ptr(slots, group_id, &red->u.opaque, &qxl->u.opaque, flags);
> + red_get_opaque_ptr(slots, group_id, &red_drawable->u.opaque, &qxl_drawable->u.opaque, flags);
> break;
> case QXL_DRAW_INVERS:
> - red_get_invers_ptr(slots, group_id, &red->u.invers, &qxl->u.invers, flags);
> + red_get_invers_ptr(slots, group_id, &red_drawable->u.invers, &qxl_drawable->u.invers, flags);
> break;
> case QXL_DRAW_NOP:
> break;
> case QXL_DRAW_ROP3:
> - red_get_rop3_ptr(slots, group_id, &red->u.rop3, &qxl->u.rop3, flags);
> + red_get_rop3_ptr(slots, group_id, &red_drawable->u.rop3, &qxl_drawable->u.rop3, flags);
> break;
> case QXL_DRAW_COMPOSITE:
> - red_get_composite_ptr(slots, group_id, &red->u.composite, &qxl->u.composite, flags);
> + red_get_composite_ptr(slots, group_id, &red_drawable->u.composite, &qxl_drawable->u.composite, flags);
> break;
> case QXL_DRAW_STROKE:
> - return red_get_stroke_ptr(slots, group_id, &red->u.stroke, &qxl->u.stroke, flags);
> + return red_get_stroke_ptr(slots, group_id, &red_drawable->u.stroke, &qxl_drawable->u.stroke, flags);
> case QXL_DRAW_TEXT:
> - red_get_text_ptr(slots, group_id, &red->u.text, &qxl->u.text, flags);
> + red_get_text_ptr(slots, group_id, &red_drawable->u.text, &qxl_drawable->u.text, flags);
> break;
> case QXL_DRAW_TRANSPARENT:
> red_get_transparent_ptr(slots, group_id,
> - &red->u.transparent, &qxl->u.transparent, flags);
> + &red_drawable->u.transparent, &qxl_drawable->u.transparent, flags);
> break;
> case QXL_DRAW_WHITENESS:
> red_get_whiteness_ptr(slots, group_id,
> - &red->u.whiteness, &qxl->u.whiteness, flags);
> + &red_drawable->u.whiteness, &qxl_drawable->u.whiteness, flags);
> break;
> default:
> - spice_warning("unknown type %d", red->type);
> + spice_warning("unknown type %d", red_drawable->type);
> return false;
> };
> return true;
> }
>
> static bool red_get_compat_drawable(RedMemSlotInfo *slots, int group_id,
> - RedDrawable *red, QXLPHYSICAL addr, uint32_t flags)
> + RedDrawable *red_drawable, QXLPHYSICAL addr, uint32_t flags)
> {
> - QXLCompatDrawable *qxl;
> + QXLCompatDrawable *qxl_drawable;
> int error;
>
> - qxl = (QXLCompatDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_drawable = (QXLCompatDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl_drawable), group_id, &error);
> if (error) {
> return false;
> }
> - red->release_info_ext.info = &qxl->release_info;
> - red->release_info_ext.group_id = group_id;
> + red_drawable->release_info_ext.info = &qxl_drawable->release_info;
> + red_drawable->release_info_ext.group_id = group_id;
>
> - red_get_rect_ptr(&red->bbox, &qxl->bbox);
> - red_get_clip_ptr(slots, group_id, &red->clip, &qxl->clip);
> - red->effect = qxl->effect;
> - red->mm_time = qxl->mm_time;
> + red_get_rect_ptr(&red_drawable->bbox, &qxl_drawable->bbox);
> + red_get_clip_ptr(slots, group_id, &red_drawable->clip, &qxl_drawable->clip);
> + red_drawable->effect = qxl_drawable->effect;
> + red_drawable->mm_time = qxl_drawable->mm_time;
>
> - red->self_bitmap = (qxl->bitmap_offset != 0);
> - red_get_rect_ptr(&red->self_bitmap_area, &qxl->bitmap_area);
> + red_drawable->self_bitmap = (qxl_drawable->bitmap_offset != 0);
> + red_get_rect_ptr(&red_drawable->self_bitmap_area, &qxl_drawable->bitmap_area);
>
> - red->surface_deps[0] = -1;
> - red->surface_deps[1] = -1;
> - red->surface_deps[2] = -1;
> + red_drawable->surface_deps[0] = -1;
> + red_drawable->surface_deps[1] = -1;
> + red_drawable->surface_deps[2] = -1;
>
> - red->type = qxl->type;
> - switch (red->type) {
> + red_drawable->type = qxl_drawable->type;
> + switch (red_drawable->type) {
> case QXL_DRAW_ALPHA_BLEND:
> red_get_alpha_blend_ptr_compat(slots, group_id,
> - &red->u.alpha_blend, &qxl->u.alpha_blend, flags);
> + &red_drawable->u.alpha_blend, &qxl_drawable->u.alpha_blend, flags);
> break;
> case QXL_DRAW_BLACKNESS:
> red_get_blackness_ptr(slots, group_id,
> - &red->u.blackness, &qxl->u.blackness, flags);
> + &red_drawable->u.blackness, &qxl_drawable->u.blackness, flags);
> break;
> case QXL_DRAW_BLEND:
> - return red_get_blend_ptr(slots, group_id, &red->u.blend, &qxl->u.blend, flags);
> + return red_get_blend_ptr(slots, group_id, &red_drawable->u.blend, &qxl_drawable->u.blend, flags);
> case QXL_DRAW_COPY:
> - return red_get_copy_ptr(slots, group_id, &red->u.copy, &qxl->u.copy, flags);
> + return red_get_copy_ptr(slots, group_id, &red_drawable->u.copy, &qxl_drawable->u.copy, flags);
> case QXL_COPY_BITS:
> - red_get_point_ptr(&red->u.copy_bits.src_pos, &qxl->u.copy_bits.src_pos);
> - red->surface_deps[0] = 0;
> - red->surfaces_rects[0].left = red->u.copy_bits.src_pos.x;
> - red->surfaces_rects[0].right = red->u.copy_bits.src_pos.x +
> - (red->bbox.right - red->bbox.left);
> - red->surfaces_rects[0].top = red->u.copy_bits.src_pos.y;
> - red->surfaces_rects[0].bottom = red->u.copy_bits.src_pos.y +
> - (red->bbox.bottom - red->bbox.top);
> + red_get_point_ptr(&red_drawable->u.copy_bits.src_pos, &qxl_drawable->u.copy_bits.src_pos);
> + red_drawable->surface_deps[0] = 0;
> + red_drawable->surfaces_rects[0].left = red_drawable->u.copy_bits.src_pos.x;
> + red_drawable->surfaces_rects[0].right = red_drawable->u.copy_bits.src_pos.x +
> + (red_drawable->bbox.right - red_drawable->bbox.left);
> + red_drawable->surfaces_rects[0].top = red_drawable->u.copy_bits.src_pos.y;
> + red_drawable->surfaces_rects[0].bottom = red_drawable->u.copy_bits.src_pos.y +
> + (red_drawable->bbox.bottom - red_drawable->bbox.top);
> break;
> case QXL_DRAW_FILL:
> - red_get_fill_ptr(slots, group_id, &red->u.fill, &qxl->u.fill, flags);
> + red_get_fill_ptr(slots, group_id, &red_drawable->u.fill, &qxl_drawable->u.fill, flags);
> break;
> case QXL_DRAW_OPAQUE:
> - red_get_opaque_ptr(slots, group_id, &red->u.opaque, &qxl->u.opaque, flags);
> + red_get_opaque_ptr(slots, group_id, &red_drawable->u.opaque, &qxl_drawable->u.opaque, flags);
> break;
> case QXL_DRAW_INVERS:
> - red_get_invers_ptr(slots, group_id, &red->u.invers, &qxl->u.invers, flags);
> + red_get_invers_ptr(slots, group_id, &red_drawable->u.invers, &qxl_drawable->u.invers, flags);
> break;
> case QXL_DRAW_NOP:
> break;
> case QXL_DRAW_ROP3:
> - red_get_rop3_ptr(slots, group_id, &red->u.rop3, &qxl->u.rop3, flags);
> + red_get_rop3_ptr(slots, group_id, &red_drawable->u.rop3, &qxl_drawable->u.rop3, flags);
> break;
> case QXL_DRAW_STROKE:
> - return red_get_stroke_ptr(slots, group_id, &red->u.stroke, &qxl->u.stroke, flags);
> + return red_get_stroke_ptr(slots, group_id, &red_drawable->u.stroke, &qxl_drawable->u.stroke, flags);
> case QXL_DRAW_TEXT:
> - red_get_text_ptr(slots, group_id, &red->u.text, &qxl->u.text, flags);
> + red_get_text_ptr(slots, group_id, &red_drawable->u.text, &qxl_drawable->u.text, flags);
> break;
> case QXL_DRAW_TRANSPARENT:
> red_get_transparent_ptr(slots, group_id,
> - &red->u.transparent, &qxl->u.transparent, flags);
> + &red_drawable->u.transparent, &qxl_drawable->u.transparent, flags);
> break;
> case QXL_DRAW_WHITENESS:
> red_get_whiteness_ptr(slots, group_id,
> - &red->u.whiteness, &qxl->u.whiteness, flags);
> + &red_drawable->u.whiteness, &qxl_drawable->u.whiteness, flags);
> break;
> default:
> - spice_warning("unknown type %d", red->type);
> + spice_warning("unknown type %d", red_drawable->type);
> return false;
> };
> return true;
> }
>
> bool red_get_drawable(RedMemSlotInfo *slots, int group_id,
> - RedDrawable *red, QXLPHYSICAL addr, uint32_t flags)
> + RedDrawable *red_drawable, QXLPHYSICAL addr, uint32_t flags)
> {
> bool ret;
>
> if (flags & QXL_COMMAND_FLAG_COMPAT) {
> - ret = red_get_compat_drawable(slots, group_id, red, addr, flags);
> + ret = red_get_compat_drawable(slots, group_id, red_drawable, addr, flags);
> } else {
> - ret = red_get_native_drawable(slots, group_id, red, addr, flags);
> + ret = red_get_native_drawable(slots, group_id, red_drawable, addr, flags);
> }
> return ret;
> }
>
> -void red_put_drawable(RedDrawable *red)
> +void red_put_drawable(RedDrawable *red_drawable)
> {
> - red_put_clip(&red->clip);
> - if (red->self_bitmap_image) {
> - red_put_image(red->self_bitmap_image);
> + red_put_clip(&red_drawable->clip);
> + if (red_drawable->self_bitmap_image) {
> + red_put_image(red_drawable->self_bitmap_image);
> }
> - switch (red->type) {
> + switch (red_drawable->type) {
> case QXL_DRAW_ALPHA_BLEND:
> - red_put_alpha_blend(&red->u.alpha_blend);
> + red_put_alpha_blend(&red_drawable->u.alpha_blend);
> break;
> case QXL_DRAW_BLACKNESS:
> - red_put_blackness(&red->u.blackness);
> + red_put_blackness(&red_drawable->u.blackness);
> break;
> case QXL_DRAW_BLEND:
> - red_put_blend(&red->u.blend);
> + red_put_blend(&red_drawable->u.blend);
> break;
> case QXL_DRAW_COPY:
> - red_put_copy(&red->u.copy);
> + red_put_copy(&red_drawable->u.copy);
> break;
> case QXL_DRAW_FILL:
> - red_put_fill(&red->u.fill);
> + red_put_fill(&red_drawable->u.fill);
> break;
> case QXL_DRAW_OPAQUE:
> - red_put_opaque(&red->u.opaque);
> + red_put_opaque(&red_drawable->u.opaque);
> break;
> case QXL_DRAW_INVERS:
> - red_put_invers(&red->u.invers);
> + red_put_invers(&red_drawable->u.invers);
> break;
> case QXL_DRAW_ROP3:
> - red_put_rop3(&red->u.rop3);
> + red_put_rop3(&red_drawable->u.rop3);
> break;
> case QXL_DRAW_COMPOSITE:
> - red_put_composite(&red->u.composite);
> + red_put_composite(&red_drawable->u.composite);
> break;
> case QXL_DRAW_STROKE:
> - red_put_stroke(&red->u.stroke);
> + red_put_stroke(&red_drawable->u.stroke);
> break;
> case QXL_DRAW_TEXT:
> - red_put_text_ptr(&red->u.text);
> + red_put_text_ptr(&red_drawable->u.text);
> break;
> case QXL_DRAW_TRANSPARENT:
> - red_put_transparent(&red->u.transparent);
> + red_put_transparent(&red_drawable->u.transparent);
> break;
> case QXL_DRAW_WHITENESS:
> - red_put_whiteness(&red->u.whiteness);
> + red_put_whiteness(&red_drawable->u.whiteness);
> break;
> }
> }
>
> bool red_get_update_cmd(RedMemSlotInfo *slots, int group_id,
> - RedUpdateCmd *red, QXLPHYSICAL addr)
> + RedUpdateCmd *red_cmd, QXLPHYSICAL addr)
> {
> - QXLUpdateCmd *qxl;
> + QXLUpdateCmd *qxl_cmd;
> int error;
>
> - qxl = (QXLUpdateCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_cmd = (QXLUpdateCmd *)memslot_get_virt(slots, addr, sizeof(*qxl_cmd), group_id, &error);
> if (error) {
> return false;
> }
> - red->release_info_ext.info = &qxl->release_info;
> - red->release_info_ext.group_id = group_id;
> + red_cmd->release_info_ext.info = &qxl_cmd->release_info;
> + red_cmd->release_info_ext.group_id = group_id;
>
>
> - red_get_rect_ptr(&red->area, &qxl->area);
> - red->update_id = qxl->update_id;
> - red->surface_id = qxl->surface_id;
> + red_get_rect_ptr(&red_cmd->area, &qxl_cmd->area);
> + red_cmd->update_id = qxl_cmd->update_id;
> + red_cmd->surface_id = qxl_cmd->surface_id;
> return true;
> }
>
> -void red_put_update_cmd(RedUpdateCmd *red)
> +void red_put_update_cmd(RedUpdateCmd *red_cmd)
> {
> /* nothing yet */
> }
>
> bool red_get_message(RedMemSlotInfo *slots, int group_id,
> - RedMessage *red, QXLPHYSICAL addr)
> + RedMessage *red_message, QXLPHYSICAL addr)
> {
> - QXLMessage *qxl;
> + QXLMessage *qxl_message;
> int error;
> int memslot_id;
> unsigned long len;
> @@ -1295,29 +1298,30 @@ bool red_get_message(RedMemSlotInfo *slots, int group_id,
>
> /*
> * security alert:
> - * qxl->data[0] size isn't specified anywhere -> can't verify
> + * qxl_message->data[0] size isn't specified anywhere -> can't verify
> * luckily this is for debug logging only,
> * so we can just ignore it by default.
> */
> - qxl = (QXLMessage *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_message = (QXLMessage *)memslot_get_virt(slots, addr, sizeof(*qxl_message), group_id, &error);
> if (error) {
> return false;
> }
> - red->release_info_ext.info = &qxl->release_info;
> - red->release_info_ext.group_id = group_id;
> - red->data = qxl->data;
> - memslot_id = memslot_get_id(slots, addr+sizeof(*qxl));
> - len = memslot_max_size_virt(slots, ((intptr_t) qxl)+sizeof(*qxl), memslot_id, group_id);
> + red_message->release_info_ext.info = &qxl_message->release_info;
> + red_message->release_info_ext.group_id = group_id;
> + red_message->data = qxl_message->data;
> + memslot_id = memslot_get_id(slots, addr+sizeof(*qxl_message));
> + len = memslot_max_size_virt(slots, ((intptr_t) qxl_message)+sizeof(*qxl_message),
> + memslot_id, group_id);
> len = MIN(len, 100000);
> - end = (uint8_t *)memchr(qxl->data, 0, len);
> + end = (uint8_t *)memchr(qxl_message->data, 0, len);
> if (end == NULL) {
> return false;
> }
> - red->len = end - qxl->data;
> + red_message->len = end - qxl_message->data;
> return true;
> }
>
> -void red_put_message(RedMessage *red)
> +void red_put_message(RedMessage *red_message)
> {
> /* nothing yet */
> }
> @@ -1369,39 +1373,39 @@ bool red_validate_surface(uint32_t width, uint32_t height,
> }
>
> bool red_get_surface_cmd(RedMemSlotInfo *slots, int group_id,
> - RedSurfaceCmd *red, QXLPHYSICAL addr)
> + RedSurfaceCmd *red_cmd, QXLPHYSICAL addr)
> {
> - QXLSurfaceCmd *qxl;
> + QXLSurfaceCmd *qxl_cmd;
> uint64_t size;
> int error;
>
> - qxl = (QXLSurfaceCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
> - &error);
> + qxl_cmd = (QXLSurfaceCmd *)memslot_get_virt(slots, addr, sizeof(*qxl_cmd), group_id,
> + &error);
> if (error) {
> return false;
> }
> - red->release_info_ext.info = &qxl->release_info;
> - red->release_info_ext.group_id = group_id;
> + red_cmd->release_info_ext.info = &qxl_cmd->release_info;
> + red_cmd->release_info_ext.group_id = group_id;
>
> - red->surface_id = qxl->surface_id;
> - red->type = qxl->type;
> - red->flags = qxl->flags;
> + red_cmd->surface_id = qxl_cmd->surface_id;
> + red_cmd->type = qxl_cmd->type;
> + red_cmd->flags = qxl_cmd->flags;
>
> - switch (red->type) {
> + switch (red_cmd->type) {
> case QXL_SURFACE_CMD_CREATE:
> - red->u.surface_create.format = qxl->u.surface_create.format;
> - red->u.surface_create.width = qxl->u.surface_create.width;
> - red->u.surface_create.height = qxl->u.surface_create.height;
> - red->u.surface_create.stride = qxl->u.surface_create.stride;
> + red_cmd->u.surface_create.format = qxl_cmd->u.surface_create.format;
> + red_cmd->u.surface_create.width = qxl_cmd->u.surface_create.width;
> + red_cmd->u.surface_create.height = qxl_cmd->u.surface_create.height;
> + red_cmd->u.surface_create.stride = qxl_cmd->u.surface_create.stride;
>
> - if (!red_validate_surface(red->u.surface_create.width, red->u.surface_create.height,
> - red->u.surface_create.stride, red->u.surface_create.format)) {
> + if (!red_validate_surface(red_cmd->u.surface_create.width, red_cmd->u.surface_create.height,
> + red_cmd->u.surface_create.stride, red_cmd->u.surface_create.format)) {
> return false;
> }
>
> - size = red->u.surface_create.height * abs(red->u.surface_create.stride);
> - red->u.surface_create.data =
> - (uint8_t*)memslot_get_virt(slots, qxl->u.surface_create.data, size, group_id, &error);
> + size = red_cmd->u.surface_create.height * abs(red_cmd->u.surface_create.stride);
> + red_cmd->u.surface_create.data =
> + (uint8_t*)memslot_get_virt(slots, qxl_cmd->u.surface_create.data, size, group_id, &error);
> if (error) {
> return false;
> }
> @@ -1410,95 +1414,95 @@ bool red_get_surface_cmd(RedMemSlotInfo *slots, int group_id,
> return true;
> }
>
> -void red_put_surface_cmd(RedSurfaceCmd *red)
> +void red_put_surface_cmd(RedSurfaceCmd *red_cmd)
> {
> /* nothing yet */
> }
>
> static bool red_get_cursor(RedMemSlotInfo *slots, int group_id,
> - SpiceCursor *red, QXLPHYSICAL addr)
> + SpiceCursor *red_cursor, QXLPHYSICAL addr)
> {
> - QXLCursor *qxl;
> + QXLCursor *qxl_cursor;
> RedDataChunk chunks;
> size_t size;
> uint8_t *data;
> bool free_data;
> int error;
>
> - qxl = (QXLCursor *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_cursor = (QXLCursor *)memslot_get_virt(slots, addr, sizeof(*qxl_cursor), group_id, &error);
> if (error) {
> return false;
> }
>
> - red->header.unique = qxl->header.unique;
> - red->header.type = qxl->header.type;
> - red->header.width = qxl->header.width;
> - red->header.height = qxl->header.height;
> - red->header.hot_spot_x = qxl->header.hot_spot_x;
> - red->header.hot_spot_y = qxl->header.hot_spot_y;
> + red_cursor->header.unique = qxl_cursor->header.unique;
> + red_cursor->header.type = qxl_cursor->header.type;
> + red_cursor->header.width = qxl_cursor->header.width;
> + red_cursor->header.height = qxl_cursor->header.height;
> + red_cursor->header.hot_spot_x = qxl_cursor->header.hot_spot_x;
> + red_cursor->header.hot_spot_y = qxl_cursor->header.hot_spot_y;
>
> - red->flags = 0;
> - red->data_size = qxl->data_size;
> + red_cursor->flags = 0;
> + red_cursor->data_size = qxl_cursor->data_size;
> size = red_get_data_chunks_ptr(slots, group_id,
> memslot_get_id(slots, addr),
> - &chunks, &qxl->chunk);
> + &chunks, &qxl_cursor->chunk);
> if (size == INVALID_SIZE) {
> return false;
> }
> - red->data_size = MIN(red->data_size, size);
> + red_cursor->data_size = MIN(red_cursor->data_size, size);
> data = red_linearize_chunk(&chunks, size, &free_data);
> red_put_data_chunks(&chunks);
> if (free_data) {
> - red->data = data;
> + red_cursor->data = data;
> } else {
> - red->data = g_memdup(data, size);
> + red_cursor->data = g_memdup(data, size);
> }
> return true;
> }
>
> -static void red_put_cursor(SpiceCursor *red)
> +static void red_put_cursor(SpiceCursor *red_cmd)
> {
> - g_free(red->data);
> + g_free(red_cmd->data);
> }
>
> bool red_get_cursor_cmd(RedMemSlotInfo *slots, int group_id,
> - RedCursorCmd *red, QXLPHYSICAL addr)
> + RedCursorCmd *red_cmd, QXLPHYSICAL addr)
> {
> - QXLCursorCmd *qxl;
> + QXLCursorCmd *qxl_cmd;
> int error;
>
> - qxl = (QXLCursorCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
> + qxl_cmd = (QXLCursorCmd *)memslot_get_virt(slots, addr, sizeof(*qxl_cmd), group_id, &error);
> if (error) {
> return false;
> }
> - red->release_info_ext.info = &qxl->release_info;
> - red->release_info_ext.group_id = group_id;
> + red_cmd->release_info_ext.info = &qxl_cmd->release_info;
> + red_cmd->release_info_ext.group_id = group_id;
>
> - red->type = qxl->type;
> - switch (red->type) {
> + red_cmd->type = qxl_cmd->type;
> + switch (red_cmd->type) {
> case QXL_CURSOR_SET:
> - red_get_point16_ptr(&red->u.set.position, &qxl->u.set.position);
> - red->u.set.visible = qxl->u.set.visible;
> - return red_get_cursor(slots, group_id, &red->u.set.shape, qxl->u.set.shape);
> + red_get_point16_ptr(&red_cmd->u.set.position, &qxl_cmd->u.set.position);
> + red_cmd->u.set.visible = qxl_cmd->u.set.visible;
> + return red_get_cursor(slots, group_id, &red_cmd->u.set.shape, qxl_cmd->u.set.shape);
> case QXL_CURSOR_MOVE:
> - red_get_point16_ptr(&red->u.position, &qxl->u.position);
> + red_get_point16_ptr(&red_cmd->u.position, &qxl_cmd->u.position);
> break;
> case QXL_CURSOR_TRAIL:
> - red->u.trail.length = qxl->u.trail.length;
> - red->u.trail.frequency = qxl->u.trail.frequency;
> + red_cmd->u.trail.length = qxl_cmd->u.trail.length;
> + red_cmd->u.trail.frequency = qxl_cmd->u.trail.frequency;
> break;
> }
> return true;
> }
>
> -void red_put_cursor_cmd(RedCursorCmd *red)
> +void red_put_cursor_cmd(RedCursorCmd *red_cmd)
> {
> - switch (red->type) {
> + switch (red_cmd->type) {
> case QXL_CURSOR_SET:
> - red_put_cursor(&red->u.set.shape);
> + red_put_cursor(&red_cmd->u.set.shape);
> break;
> }
> - if (red->qxl) {
> - red_qxl_release_resource(red->qxl, red->release_info_ext);
> + if (red_cmd->qxl) {
> + red_qxl_release_resource(red_cmd->qxl, red_cmd->release_info_ext);
> }
> }
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel