>
> >
> > This patch is freaking huge :-\
> > Is there some automated way to check whether a function move is just a
> > move or something else changed?
> >
>
> Do you mean something like this?
>
>
> --- before.c 2015-11-26 09:57:02.327008820 +0000
> +++ after.c 2015-11-26 09:19:38.642524996 +0000
> @@ -34,20 +34,22 @@
> #define DISPLAY_CLIENT_TIMEOUT 30000000000ULL //nano
> #define DISPLAY_CLIENT_MIGRATE_DATA_TIMEOUT 10000000000ULL //nano, 10 sec
> #define DISPLAY_CLIENT_RETRY_INTERVAL 10000 //micro
>
> /* Each drawable can refer to at most 3 images: src, brush and mask */
> #define MAX_DRAWABLE_PIXMAP_CACHE_ITEMS 3
>
> #define WIDE_CLIENT_ACK_WINDOW 40
> #define NARROW_CLIENT_ACK_WINDOW 20
>
> +#define MAX_PIPE_SIZE 50
> +
> typedef struct WaitForChannels {
> SpiceMsgWaitForChannels header;
> SpiceWaitForChannel buf[MAX_CACHE_CLIENTS];
> } WaitForChannels;
>
> typedef struct FreeList {
> int res_size;
> SpiceResourceList *res;
> uint64_t sync[MAX_CACHE_CLIENTS];
> WaitForChannels wait;
> @@ -367,20 +369,21 @@
> pixmap-cache.c \
> tree.h \
> tree.c \
> spice-bitmap-utils.h \
> spice-bitmap-utils.c \
> utils.c \
> utils.h \
> stream.c \
> stream.h \
> dcc.c \
> + dcc-send.c \
> dcc.h \
> display-limits.h \
> dcc-encoders.c \
> dcc-encoders.h \
> $(NULL)
>
> if HAVE_SMARTCARD
> libspice_server_la_SOURCES += \
> smartcard.c \
> smartcard.h \
> @@ -516,24 +519,20 @@
> out_lossy_area->top = lossy_region.extents.y1;
> out_lossy_area->right = lossy_region.extents.x2;
> out_lossy_area->bottom = lossy_region.extents.y2;
> region_destroy(&lossy_region);
> return TRUE;
> } else {
> return FALSE;
> }
> }
>
> -/* returns if the bitmap was already sent lossy to the client. If the bitmap
> hasn't been sent yet
> - to the client, returns false. "area" is for surfaces. If area = NULL,
> - all the surface is considered. out_lossy_data will hold info about the
> bitmap, and its lossy
> - area in case it is lossy and part of a surface. */
Note that this comment was moved in front to another function, I'll revert
this change and ack the patch.
> static int is_bitmap_lossy(RedChannelClient *rcc, SpiceImage *image,
> SpiceRect *area,
> Drawable *drawable, BitmapData *out_data)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>
> if (image == NULL) {
> // self bitmap
> out_data->type = BITMAP_DATA_TYPE_BITMAP;
> return FALSE;
> }
> @@ -608,73 +607,73 @@
> stat_inc_counter(display_channel->add_to_cache_counter, 1);
> }
> }
> }
>
> if (!(io_image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) {
> stat_inc_counter(display_channel->non_cache_counter, 1);
> }
> }
>
> -static inline void display_marshal_sub_msg_inval_list(SpiceMarshaller *m,
> +static void marshal_sub_msg_inval_list(SpiceMarshaller *m,
> FreeList *free_list)
> {
> /* type + size + submessage */
> spice_marshaller_add_uint16(m, SPICE_MSG_DISPLAY_INVAL_LIST);
> spice_marshaller_add_uint32(m, sizeof(*free_list->res) +
> free_list->res->count *
> sizeof(free_list->res->resources[0]));
> spice_marshall_msg_display_inval_list(m, free_list->res);
> }
>
> -static inline void display_marshal_sub_msg_inval_list_wait(SpiceMarshaller
> *m,
> +static void marshal_sub_msg_inval_list_wait(SpiceMarshaller *m,
> FreeList
> *free_list)
> {
> /* type + size + submessage */
> spice_marshaller_add_uint16(m, SPICE_MSG_WAIT_FOR_CHANNELS);
> spice_marshaller_add_uint32(m, sizeof(free_list->wait.header) +
> free_list->wait.header.wait_count *
> sizeof(free_list->wait.buf[0]));
> spice_marshall_msg_wait_for_channels(m, &free_list->wait.header);
> }
>
> /* use legacy SpiceDataHeader (with sub_list) */
> -static inline void display_channel_send_free_list_legacy(RedChannelClient
> *rcc)
> +static void send_free_list_legacy(RedChannelClient *rcc)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> FreeList *free_list = &dcc->send_data.free_list;
> SpiceMarshaller *marshaller;
> int sub_list_len = 1;
> SpiceMarshaller *wait_m = NULL;
> SpiceMarshaller *inval_m;
> SpiceMarshaller *sub_list_m;
>
> marshaller = red_channel_client_get_marshaller(rcc);
> inval_m = spice_marshaller_get_submarshaller(marshaller);
>
> - display_marshal_sub_msg_inval_list(inval_m, free_list);
> + marshal_sub_msg_inval_list(inval_m, free_list);
>
> if (free_list->wait.header.wait_count) {
> wait_m = spice_marshaller_get_submarshaller(marshaller);
> - display_marshal_sub_msg_inval_list_wait(wait_m, free_list);
> + marshal_sub_msg_inval_list_wait(wait_m, free_list);
> sub_list_len++;
> }
>
> sub_list_m = spice_marshaller_get_submarshaller(marshaller);
> spice_marshaller_add_uint16(sub_list_m, sub_list_len);
> if (wait_m) {
> spice_marshaller_add_uint32(sub_list_m,
> spice_marshaller_get_offset(wait_m));
> }
> spice_marshaller_add_uint32(sub_list_m,
> spice_marshaller_get_offset(inval_m));
> red_channel_client_set_header_sub_list(rcc,
> spice_marshaller_get_offset(sub_list_m));
> }
>
> /* use mini header and SPICE_MSG_LIST */
> -static inline void display_channel_send_free_list(RedChannelClient *rcc)
> +static void send_free_list(RedChannelClient *rcc)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> FreeList *free_list = &dcc->send_data.free_list;
> int sub_list_len = 1;
> SpiceMarshaller *urgent_marshaller;
> SpiceMarshaller *wait_m = NULL;
> SpiceMarshaller *inval_m;
> uint32_t sub_arr_offset;
> uint32_t wait_offset = 0;
> uint32_t inval_offset = 0;
> @@ -693,25 +692,25 @@
>
> if (free_list->wait.header.wait_count) {
> red_channel_client_init_send_data(rcc, SPICE_MSG_LIST, NULL);
> } else { /* only one message, no need for a list */
> red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_INVAL_LIST,
> NULL);
> spice_marshall_msg_display_inval_list(urgent_marshaller,
> free_list->res);
> return;
> }
>
> inval_m = spice_marshaller_get_submarshaller(urgent_marshaller);
> - display_marshal_sub_msg_inval_list(inval_m, free_list);
> + marshal_sub_msg_inval_list(inval_m, free_list);
>
> if (free_list->wait.header.wait_count) {
> wait_m = spice_marshaller_get_submarshaller(urgent_marshaller);
> - display_marshal_sub_msg_inval_list_wait(wait_m, free_list);
> + marshal_sub_msg_inval_list_wait(wait_m, free_list);
> sub_list_len++;
> }
>
> sub_arr_offset = sub_list_len * sizeof(uint32_t);
>
> spice_marshaller_add_uint16(urgent_marshaller, sub_list_len);
> inval_offset = spice_marshaller_get_offset(inval_m); // calc the offset
> before
> // adding the sub
> list
> // offsets array to
> the marshaller
> /* adding the array of offsets */
> @@ -903,21 +902,21 @@
> {
> int i;
>
> if (m && attr->style_nseg) {
> for (i = 0 ; i < attr->style_nseg; i++) {
> spice_marshaller_add_uint32(m, attr->style[i]);
> }
> }
> }
>
> -static void red_marshall_qxl_draw_fill(RedChannelClient *rcc,
> +static void marshall_qxl_draw_fill(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller,
> DrawablePipeItem *dpi)
> {
> Drawable *item = dpi->drawable;
> RedDrawable *drawable = item->red_drawable;
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> SpiceMarshaller *brush_pat_out;
> SpiceMarshaller *mask_bitmap_out;
> SpiceFill fill;
>
> @@ -929,20 +928,24 @@
> &brush_pat_out,
> &mask_bitmap_out);
>
> if (brush_pat_out) {
> fill_bits(dcc, brush_pat_out, fill.brush.u.pattern.pat, item,
> FALSE);
> }
>
> fill_mask(rcc, mask_bitmap_out, fill.mask.bitmap, item);
> }
>
> +/* returns if the bitmap was already sent lossy to the client. If the bitmap
> hasn't been sent yet
> + to the client, returns false. "area" is for surfaces. If area = NULL,
> + all the surface is considered. out_lossy_data will hold info about the
> bitmap, and its lossy
> + area in case it is lossy and part of a surface. */
Here you are the comment moved to another function
> static void surface_lossy_region_update(DisplayChannelClient *dcc,
> Drawable *item, int has_mask, int
> lossy)
> {
> QRegion *surface_lossy_region;
> RedDrawable *drawable;
>
> if (has_mask && !lossy) {
> return;
> }
>
> @@ -967,21 +970,21 @@
> region_destroy(&draw_region);
> } else { /* no clip */
> if (!lossy) {
> region_remove(surface_lossy_region, &drawable->bbox);
> } else {
> region_add(surface_lossy_region, &drawable->bbox);
> }
> }
> }
>
> -static inline int drawable_intersects_with_areas(Drawable *drawable, int
> surface_ids[],
> +static int drawable_intersects_with_areas(Drawable *drawable, int
> surface_ids[],
> SpiceRect *surface_areas[],
> int num_surfaces)
> {
> int i;
> for (i = 0; i < num_surfaces; i++) {
> if (surface_ids[i] == drawable->red_drawable->surface_id) {
> if (rect_intersects(surface_areas[i],
> &drawable->red_drawable->bbox)) {
> return TRUE;
> }
> }
> @@ -1014,24 +1017,22 @@
> continue; // item hasn't been rendered
>
> if (drawable_intersects_with_areas(drawable, surface_ids,
> surface_areas, num_surfaces)) {
> return TRUE;
> }
> }
>
> return FALSE;
> }
>
> -static inline int drawable_depends_on_areas(Drawable *drawable,
> - int surface_ids[],
> - SpiceRect surface_areas[],
> - int num_surfaces)
> +static int drawable_depends_on_areas(Drawable *drawable, int surface_ids[],
> + SpiceRect surface_areas[], int
> num_surfaces)
> {
> int i;
> RedDrawable *red_drawable;
> int drawable_has_shadow;
> SpiceRect shadow_rect = {0, 0, 0, 0};
>
> red_drawable = drawable->red_drawable;
> drawable_has_shadow = has_shadow(red_drawable);
>
> if (drawable_has_shadow) {
> @@ -1227,21 +1228,21 @@
> &brush_bitmap_data);
> if (!dest_allowed_lossy) {
> dest_is_lossy = is_surface_area_lossy(dcc, item->surface_id,
> &drawable->bbox,
> &dest_lossy_area);
> }
>
> if (!dest_is_lossy &&
> !(brush_is_lossy && (brush_bitmap_data.type ==
> BITMAP_DATA_TYPE_SURFACE))) {
> int has_mask = !!drawable->u.fill.mask.bitmap;
>
> - red_marshall_qxl_draw_fill(rcc, m, dpi);
> + marshall_qxl_draw_fill(rcc, m, dpi);
> // either the brush operation is opaque, or the dest is not lossy
> surface_lossy_region_update(dcc, item, has_mask, FALSE);
> } else {
> int resend_surface_ids[2];
> SpiceRect *resend_areas[2];
> int num_resend = 0;
>
> if (dest_is_lossy) {
> resend_surface_ids[num_resend] = item->surface_id;
> resend_areas[num_resend] = &dest_lossy_area;
> @@ -2161,21 +2162,21 @@
> agent->last_send_time = time_now;
> #ifdef STREAM_STATS
> agent->stats.num_frames_sent++;
> agent->stats.size_sent += n;
> agent->stats.end = frame_mm_time;
> #endif
>
> return TRUE;
> }
>
> -static inline void red_marshall_inval_palette(RedChannelClient *rcc,
> +static inline void marshall_inval_palette(RedChannelClient *rcc,
> SpiceMarshaller
> *base_marshaller,
> CacheItem *cache_item)
> {
> SpiceMsgDisplayInvalOne inval_one;
>
> red_channel_client_init_send_data(rcc, cache_item->inval_type, NULL);
> inval_one.id = *(uint64_t *)&cache_item->id;
>
> spice_marshall_msg_display_inval_palette(base_marshaller, &inval_one);
>
> @@ -2394,41 +2395,39 @@
> if (grad_level == BITMAP_GRADUAL_HIGH) {
> // if we use lz for alpha, the stride can't be extra
> lossy_comp = display->enable_jpeg && item->can_lossy;
> quic_comp = TRUE;
> }
> }
> } else if (comp_mode == SPICE_IMAGE_COMPRESSION_QUIC) {
> quic_comp = TRUE;
> }
>
> + uint32_t groupid =
> red_worker_get_memslot(worker)->internal_groupslot_id;
> +
> if (lossy_comp) {
> - comp_succeeded = dcc_compress_image_jpeg(dcc, &red_image,
> - &bitmap, &comp_send_data,
> -
> worker->mem_slots.internal_groupslot_id);
> + comp_succeeded = dcc_compress_image_jpeg(dcc, &red_image, &bitmap,
> &comp_send_data, groupid);
> } else if (quic_comp) {
> - comp_succeeded = dcc_compress_image_quic(dcc, &red_image, &bitmap,
> - &comp_send_data,
> -
> worker->mem_slots.internal_groupslot_id);
> + comp_succeeded = dcc_compress_image_quic(dcc, &red_image, &bitmap,
> &comp_send_data, groupid);
> #ifdef USE_LZ4
> } else if (comp_mode == SPICE_IMAGE_COMPRESSION_LZ4 &&
> bitmap_fmt_is_rgb(bitmap.format) &&
> red_channel_client_test_remote_cap(&dcc->common.base,
> SPICE_DISPLAY_CAP_LZ4_COMPRESSION))
> {
> comp_succeeded = dcc_compress_image_lz4(dcc, &red_image, &bitmap,
> &comp_send_data,
> -
> worker->mem_slots.internal_groupslot_id);
> + groupid);
> #endif
> } else if (comp_mode != SPICE_IMAGE_COMPRESSION_OFF) {
> comp_succeeded = dcc_compress_image_lz(dcc, &red_image, &bitmap,
> &comp_send_data,
> -
> worker->mem_slots.internal_groupslot_id);
> + groupid);
> }
>
> surface_lossy_region =
> &dcc->surface_client_lossy_region[item->surface_id];
> if (comp_succeeded) {
> spice_marshall_Image(src_bitmap_out, &red_image,
> &bitmap_palette_out, &lzplt_palette_out);
>
> marshaller_add_compressed(src_bitmap_out,
> comp_send_data.comp_buf,
> comp_send_data.comp_buf_size);
>
> @@ -2447,21 +2446,21 @@
>
> spice_marshall_Image(src_bitmap_out, &red_image,
> &bitmap_palette_out, &lzplt_palette_out);
> spice_marshaller_add_ref(src_bitmap_out, item->data,
> bitmap.y * bitmap.stride);
> region_remove(surface_lossy_region, ©.base.box);
> }
> spice_chunks_destroy(chunks);
> }
>
> -static void red_lossy_marshall_qxl_drawable(RedChannelClient *rcc,
> +static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
> SpiceMarshaller
> *base_marshaller,
> DrawablePipeItem *dpi)
> {
> Drawable *item = dpi->drawable;
> switch (item->red_drawable->type) {
> case QXL_DRAW_FILL:
> red_lossy_marshall_qxl_draw_fill(rcc, base_marshaller, dpi);
> break;
> case QXL_DRAW_OPAQUE:
> red_lossy_marshall_qxl_draw_opaque(rcc, base_marshaller, dpi);
> @@ -2496,33 +2495,33 @@
> case QXL_DRAW_COMPOSITE:
> red_lossy_marshall_qxl_draw_composite(rcc, base_marshaller, dpi);
> break;
> case QXL_DRAW_STROKE:
> red_lossy_marshall_qxl_draw_stroke(rcc, base_marshaller, dpi);
> break;
> case QXL_DRAW_TEXT:
> red_lossy_marshall_qxl_draw_text(rcc, base_marshaller, dpi);
> break;
> default:
> - spice_error("invalid type");
> + spice_warn_if_reached();
> }
> }
>
> -static inline void red_marshall_qxl_drawable(RedChannelClient *rcc,
> +static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
> SpiceMarshaller *m,
> DrawablePipeItem *dpi)
> {
> Drawable *item = dpi->drawable;
> RedDrawable *drawable = item->red_drawable;
>
> switch (drawable->type) {
> case QXL_DRAW_FILL:
> - red_marshall_qxl_draw_fill(rcc, m, dpi);
> + marshall_qxl_draw_fill(rcc, m, dpi);
> break;
> case QXL_DRAW_OPAQUE:
> red_marshall_qxl_draw_opaque(rcc, m, dpi, FALSE);
> break;
> case QXL_DRAW_COPY:
> red_marshall_qxl_draw_copy(rcc, m, dpi, FALSE);
> break;
> case QXL_DRAW_TRANSPARENT:
> red_marshall_qxl_draw_transparent(rcc, m, dpi);
> break;
> @@ -2550,43 +2549,44 @@
> case QXL_DRAW_STROKE:
> red_marshall_qxl_draw_stroke(rcc, m, dpi);
> break;
> case QXL_DRAW_COMPOSITE:
> red_marshall_qxl_draw_composite(rcc, m, dpi);
> break;
> case QXL_DRAW_TEXT:
> red_marshall_qxl_draw_text(rcc, m, dpi);
> break;
> default:
> - spice_error("invalid type");
> + spice_warn_if_reached();
> }
> }
>
> -static inline void marshall_qxl_drawable(RedChannelClient *rcc,
> +static void marshall_qxl_drawable(RedChannelClient *rcc,
> SpiceMarshaller *m, DrawablePipeItem *dpi)
> {
> Drawable *item = dpi->drawable;
> DisplayChannel *display = SPICE_CONTAINEROF(rcc->channel,
> DisplayChannel, common.base);
>
> - spice_assert(display && rcc);
> + spice_return_if_fail(display);
> + spice_return_if_fail(rcc);
Here there is a bug. rcc is tested for NULL after being used to initialize display.
This is not a regression however.
I'll move the spice_return_if_fail(rcc) at the beginning of the function.
Returning here is not a problem.
> /* allow sized frames to be streamed, even if they where replaced by
> another frame, since
> * newer frames might not cover sized frames completely if they are
> bigger */
> if ((item->stream || item->sized_stream) &&
> red_marshall_stream_data(rcc, m, item)) {
> return;
> }
> - if (!display->enable_jpeg)
> - red_marshall_qxl_drawable(rcc, m, dpi);
> + if (display->enable_jpeg)
> + marshall_lossy_qxl_drawable(rcc, m, dpi);
> else
> - red_lossy_marshall_qxl_drawable(rcc, m, dpi);
> + marshall_lossless_qxl_drawable(rcc, m, dpi);
> }
>
> -static void red_display_marshall_stream_start(RedChannelClient *rcc,
> +static void marshall_stream_start(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller, StreamAgent *agent)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> Stream *stream = agent->stream;
>
> agent->last_send_time = 0;
> spice_assert(stream);
> red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_CREATE,
> NULL);
> SpiceMsgDisplayStreamCreate stream_create;
> SpiceClipRects clip_rects;
> @@ -2609,52 +2609,52 @@
> stream_create.clip.type = SPICE_CLIP_TYPE_RECTS;
> clip_rects.num_rects = 0;
> stream_create.clip.rects = &clip_rects;
> }
>
> stream_create.stamp = 0;
>
> spice_marshall_msg_display_stream_create(base_marshaller,
> &stream_create);
> }
>
> -static void red_display_marshall_stream_clip(RedChannelClient *rcc,
> +static void marshall_stream_clip(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller,
> StreamClipItem *item)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> StreamAgent *agent = item->stream_agent;
>
> - spice_assert(agent->stream);
> + spice_return_if_fail(agent->stream);
>
> red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_CLIP,
> &item->base);
> SpiceMsgDisplayStreamClip stream_clip;
>
> stream_clip.id = get_stream_id(DCC_TO_DC(dcc), agent->stream);
> stream_clip.clip.type = item->clip_type;
> stream_clip.clip.rects = item->rects;
>
> spice_marshall_msg_display_stream_clip(base_marshaller, &stream_clip);
> }
>
> -static void red_display_marshall_stream_end(RedChannelClient *rcc,
> +static void marshall_stream_end(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller, StreamAgent* agent)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> SpiceMsgDisplayStreamDestroy destroy;
>
> red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_DESTROY,
> NULL);
> destroy.id = get_stream_id(DCC_TO_DC(dcc), agent->stream);
> stream_agent_stop(agent);
> spice_marshall_msg_display_stream_destroy(base_marshaller, &destroy);
> }
>
> -static void red_display_marshall_upgrade(RedChannelClient *rcc,
> SpiceMarshaller *m,
> +static void marshall_upgrade(RedChannelClient *rcc, SpiceMarshaller *m,
> UpgradeItem *item)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> RedDrawable *red_drawable;
> SpiceMsgDisplayDrawCopy copy;
> SpiceMarshaller *src_bitmap_out, *mask_bitmap_out;
>
> spice_assert(rcc && rcc->channel && item && item->drawable);
> red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_DRAW_COPY,
> &item->base);
>
> @@ -2668,46 +2668,47 @@
> copy.base.clip.type = SPICE_CLIP_TYPE_RECTS;
> copy.base.clip.rects = item->rects;
> copy.data = red_drawable->u.copy;
>
> spice_marshall_msg_display_draw_copy(m, ©,
> &src_bitmap_out, &mask_bitmap_out);
>
> fill_bits(dcc, src_bitmap_out, copy.data.src_bitmap, item->drawable,
> FALSE);
> }
>
> -static void red_marshall_surface_create(RedChannelClient *rcc,
> - SpiceMarshaller *base_marshaller, SpiceMsgSurfaceCreate *surface_create)
> +static void marshall_surface_create(RedChannelClient *rcc,
> + SpiceMarshaller *base_marshaller,
> + SpiceMsgSurfaceCreate *surface_create)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>
> region_init(&dcc->surface_client_lossy_region[surface_create->surface_id]);
> red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_SURFACE_CREATE,
> NULL);
>
> spice_marshall_msg_display_surface_create(base_marshaller,
> surface_create);
> }
>
> -static void red_marshall_surface_destroy(RedChannelClient *rcc,
> +static void marshall_surface_destroy(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller, uint32_t surface_id)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> SpiceMsgSurfaceDestroy surface_destroy;
>
> region_destroy(&dcc->surface_client_lossy_region[surface_id]);
> red_channel_client_init_send_data(rcc,
> SPICE_MSG_DISPLAY_SURFACE_DESTROY, NULL);
>
> surface_destroy.surface_id = surface_id;
>
> spice_marshall_msg_display_surface_destroy(base_marshaller,
> &surface_destroy);
> }
>
> -static void red_marshall_monitors_config(RedChannelClient *rcc,
> SpiceMarshaller *base_marshaller,
> +static void marshall_monitors_config(RedChannelClient *rcc, SpiceMarshaller
> *base_marshaller,
> MonitorsConfig *monitors_config)
> {
> int heads_size = sizeof(SpiceHead) * monitors_config->count;
> int i;
> SpiceMsgDisplayMonitorsConfig *msg = spice_malloc0(sizeof(*msg) +
> heads_size);
> int count = 0; // ignore monitors_config->count, it may contain zero
> width monitors, remove them now
>
> red_channel_client_init_send_data(rcc,
> SPICE_MSG_DISPLAY_MONITORS_CONFIG, NULL);
> for (i = 0 ; i < monitors_config->count; ++i) {
> if (monitors_config->heads[i].width == 0 ||
> monitors_config->heads[i].height == 0) {
> @@ -2720,58 +2721,58 @@
> msg->heads[count].x = monitors_config->heads[i].x;
> msg->heads[count].y = monitors_config->heads[i].y;
> count++;
> }
> msg->count = count;
> msg->max_allowed = monitors_config->max_allowed;
> spice_marshall_msg_display_monitors_config(base_marshaller, msg);
> free(msg);
> }
>
> -static void red_marshall_stream_activate_report(RedChannelClient *rcc,
> +static void marshall_stream_activate_report(RedChannelClient *rcc,
> SpiceMarshaller
> *base_marshaller,
> uint32_t stream_id)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> StreamAgent *agent = &dcc->stream_agents[stream_id];
> SpiceMsgDisplayStreamActivateReport msg;
>
> red_channel_client_init_send_data(rcc,
> SPICE_MSG_DISPLAY_STREAM_ACTIVATE_REPORT, NULL);
> msg.stream_id = stream_id;
> msg.unique_id = agent->report_id;
> msg.max_window_size = RED_STREAM_CLIENT_REPORT_WINDOW;
> msg.timeout_ms = RED_STREAM_CLIENT_REPORT_TIMEOUT;
> spice_marshall_msg_display_stream_activate_report(base_marshaller,
> &msg);
> }
>
> -static inline void display_begin_send_message(RedChannelClient *rcc)
> +static void begin_send_message(RedChannelClient *rcc)
> {
> DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> FreeList *free_list = &dcc->send_data.free_list;
>
> if (free_list->res->count) {
> int sync_count = 0;
> int i;
>
> for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
> if (i != dcc->common.id && free_list->sync[i] != 0) {
> free_list->wait.header.wait_list[sync_count].channel_type =
> SPICE_CHANNEL_DISPLAY;
> free_list->wait.header.wait_list[sync_count].channel_id = i;
> free_list->wait.header.wait_list[sync_count++].message_serial
> = free_list->sync[i];
> }
> }
> free_list->wait.header.wait_count = sync_count;
>
> if (rcc->is_mini_header) {
> - display_channel_send_free_list(rcc);
> + send_free_list(rcc);
> } else {
> - display_channel_send_free_list_legacy(rcc);
> + send_free_list_legacy(rcc);
> }
> }
> red_channel_client_begin_send_message(rcc);
> }
>
> static void reset_send_data(DisplayChannelClient *dcc)
> {
> dcc->send_data.free_list.res->count = 0;
> dcc->send_data.num_pixmap_cache_items = 0;
> memset(dcc->send_data.free_list.sync, 0,
> sizeof(dcc->send_data.free_list.sync));
> @@ -2783,39 +2784,39 @@
> SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
>
> reset_send_data(dcc);
> switch (pipe_item->type) {
> case PIPE_ITEM_TYPE_DRAW: {
> DrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item,
> DrawablePipeItem, dpi_pipe_item);
> marshall_qxl_drawable(rcc, m, dpi);
> break;
> }
> case PIPE_ITEM_TYPE_INVAL_ONE:
> - red_marshall_inval_palette(rcc, m, (CacheItem *)pipe_item);
> + marshall_inval_palette(rcc, m, (CacheItem *)pipe_item);
> break;
> case PIPE_ITEM_TYPE_STREAM_CREATE: {
> StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent,
> create_item);
> - red_display_marshall_stream_start(rcc, m, agent);
> + marshall_stream_start(rcc, m, agent);
> break;
> }
> case PIPE_ITEM_TYPE_STREAM_CLIP: {
> StreamClipItem* clip_item = (StreamClipItem *)pipe_item;
> - red_display_marshall_stream_clip(rcc, m, clip_item);
> + marshall_stream_clip(rcc, m, clip_item);
> break;
> }
> case PIPE_ITEM_TYPE_STREAM_DESTROY: {
> StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent,
> destroy_item);
> - red_display_marshall_stream_end(rcc, m, agent);
> + marshall_stream_end(rcc, m, agent);
> break;
> }
> case PIPE_ITEM_TYPE_UPGRADE:
> - red_display_marshall_upgrade(rcc, m, (UpgradeItem *)pipe_item);
> + marshall_upgrade(rcc, m, (UpgradeItem *)pipe_item);
> break;
> case PIPE_ITEM_TYPE_VERB:
> red_marshall_verb(rcc, (VerbItem*)pipe_item);
> break;
> case PIPE_ITEM_TYPE_MIGRATE_DATA:
> display_channel_marshall_migrate_data(rcc, m);
> break;
> case PIPE_ITEM_TYPE_IMAGE:
> red_marshall_image(rcc, m, (ImageItem *)pipe_item);
> break;
> @@ -2825,51 +2826,51 @@
> case PIPE_ITEM_TYPE_PIXMAP_RESET:
> display_channel_marshall_reset_cache(rcc, m);
> break;
> case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
> dcc_palette_cache_reset(dcc);
> red_channel_client_init_send_data(rcc,
> SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES, NULL);
> break;
> case PIPE_ITEM_TYPE_CREATE_SURFACE: {
> SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item,
> SurfaceCreateItem,
> pipe_item);
> - red_marshall_surface_create(rcc, m,
> &surface_create->surface_create);
> + marshall_surface_create(rcc, m, &surface_create->surface_create);
> break;
> }
> case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
> SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item,
> SurfaceDestroyItem,
> pipe_item);
> - red_marshall_surface_destroy(rcc, m,
> surface_destroy->surface_destroy.surface_id);
> + marshall_surface_destroy(rcc, m,
> surface_destroy->surface_destroy.surface_id);
> break;
> }
> case PIPE_ITEM_TYPE_MONITORS_CONFIG: {
> MonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
> MonitorsConfigItem,
> pipe_item);
> - red_marshall_monitors_config(rcc, m, monconf_item->monitors_config);
> + marshall_monitors_config(rcc, m, monconf_item->monitors_config);
> break;
> }
> case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
> StreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
> StreamActivateReportItem,
> pipe_item);
> - red_marshall_stream_activate_report(rcc, m, report_item->stream_id);
> + marshall_stream_activate_report(rcc, m, report_item->stream_id);
> break;
> }
> default:
> - spice_error("invalid pipe item type");
> + spice_warn_if_reached();
> }
>
> dcc_release_item(dcc, pipe_item, FALSE);
>
> // a message is pending
> if (red_channel_client_send_message_pending(rcc)) {
> - display_begin_send_message(rcc);
> + begin_send_message(rcc);
> }
> }
> /* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> /*
> Copyright (C) 2009 Red Hat, Inc.
>
> This library is free software; you can redistribute it and/or
> modify it under the terms of the GNU Lesser General Public
> License as published by the Free Software Foundation; either
> version 2.1 of the License, or (at your option) any later version.
> @@ -2910,25 +2911,23 @@
> #include <poll.h>
> #include <pthread.h>
> #include <netinet/tcp.h>
> #include <openssl/ssl.h>
> #include <inttypes.h>
> #include <glib.h>
>
> #include <spice/protocol.h>
> #include <spice/qxl_dev.h>
> #include "common/lz.h"
> -#include "common/marshaller.h"
> #include "common/rect.h"
> #include "common/region.h"
> #include "common/ring.h"
> -#include "common/generated_server_marshallers.h"
>
> #include "display-channel.h"
> #include "stream.h"
>
> #include "spice.h"
> #include "red_worker.h"
> #include "spice_timer_queue.h"
> #include "cursor-channel.h"
> #include "tree.h"
>
> @@ -2941,22 +2940,20 @@
>
> #define MAX_EVENT_SOURCES 20
> #define INF_EVENT_WAIT ~0
>
> struct SpiceWatch {
> struct RedWorker *worker;
> SpiceWatchFunc watch_func;
> void *watch_func_opaque;
> };
>
> -#define MAX_PIPE_SIZE 50
> -
> struct RedWorker {
> pthread_t thread;
> clockid_t clockid;
> QXLInstance *qxl;
> RedDispatcher *red_dispatcher;
> int running;
> struct pollfd poll_fds[MAX_EVENT_SOURCES];
> struct SpiceWatch watches[MAX_EVENT_SOURCES];
> unsigned int event_timeout;
>
> @@ -2977,29 +2974,34 @@
> StatNodeRef stat;
> uint64_t *wakeup_counter;
> uint64_t *command_counter;
> #endif
>
> int driver_cap_monitors_config;
>
> FILE *record_fd;
> };
>
> -static inline void display_begin_send_message(RedChannelClient *rcc);
> -
> QXLInstance* red_worker_get_qxl(RedWorker *worker)
> {
> spice_return_val_if_fail(worker != NULL, NULL);
>
> return worker->qxl;
> }
>
> +RedMemSlotInfo* red_worker_get_memslot(RedWorker *worker)
> +{
> + spice_return_val_if_fail(worker != NULL, NULL);
> +
> + return &worker->mem_slots;
> +}
> +
> static int display_is_connected(RedWorker *worker)
> {
> return (worker->display_channel && red_channel_is_connected(
> &worker->display_channel->common.base));
> }
>
> static int cursor_is_connected(RedWorker *worker)
> {
> return worker->cursor_channel &&
> red_channel_is_connected(RED_CHANNEL(worker->cursor_channel));
> @@ -5085,20 +5087,22 @@
> red_pipe_add_verb(rcc, verb);
> }
> }
>
> RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher);
> bool red_worker_run(RedWorker *worker);
> QXLInstance* red_worker_get_qxl(RedWorker *worker);
> RedChannel* red_worker_get_cursor_channel(RedWorker *worker);
> RedChannel* red_worker_get_display_channel(RedWorker *worker);
> clockid_t red_worker_get_clockid(RedWorker *worker);
> +RedMemSlotInfo* red_worker_get_memslot(RedWorker *worker);
> +
> void red_drawable_unref(RedWorker *worker, RedDrawable *red_drawable,
> uint32_t group_id);
>
> RedChannel *red_worker_new_channel(RedWorker *worker, int size,
> const char *name,
> uint32_t channel_type, int
> migration_flags,
> ChannelCbs *channel_cbs,
> channel_handle_parsed_proc
> handle_parsed);
>
> CommonChannelClient *common_channel_new_client(CommonChannel *common,
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@xxxxxxxxxxxxxxxxxxxxx
> http://lists.freedesktop.org/mailman/listinfo/spice-devel
>
Frediano
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/spice-devel