On Thu, Nov 26, 2015 at 11:46 AM, Frediano Ziglio <fziglio@xxxxxxxxxx> wrote:
>>
>> >
>> > 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.
Agreed!
>
>> 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
--
Fabiano Fidêncio
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/spice-devel