Re: [PATCH 09/19] worker: move dcc_send & marshallers to dcc-send.c

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

 



> 
> > 
> > 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, &copy.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, &copy,
>                                           &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




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