Re: [PATCH 09/10] Add DisplayChannelClientPrivate and CursorChannelPrivate structs

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

 



Hi,

On Wed, Aug 31, 2016 at 11:54:45AM -0500, Jonathon Jongsma wrote:
> These need to be introduced at the same time since cache-item.tmpl.c
> assumes that both of these classes will have a cache in the same place:
> either within the channel client struct itself or (now) within a priv
> struct owned by the channel client.
> 
> This encapsulates private data and prepares for porting to GObject.
> ---
>  server/cache-item.tmpl.c       |  38 +++++-----
>  server/cursor-channel-client.c |  14 +++-
>  server/dcc-private.h           |  10 ++-
>  server/dcc-send.c              | 114 ++++++++++++++--------------
>  server/dcc.c                   | 166 +++++++++++++++++++++--------------------
>  5 files changed, 181 insertions(+), 161 deletions(-)
> 
> diff --git a/server/cache-item.tmpl.c b/server/cache-item.tmpl.c
> index d1310a5..ce38a2a 100644
> --- a/server/cache-item.tmpl.c
> +++ b/server/cache-item.tmpl.c
> @@ -46,12 +46,12 @@
>  
>  static RedCacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
>  {
> -    RedCacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
> +    RedCacheItem *item = channel_client->priv->CACHE_NAME[CACHE_HASH_KEY(id)];
>  
>      while (item) {
>          if (item->id == id) {
>              ring_remove(&item->u.cache_data.lru_link);
> -            ring_add(&channel_client->VAR_NAME(lru), &item->u.cache_data.lru_link);
> +            ring_add(&channel_client->priv->VAR_NAME(lru), &item->u.cache_data.lru_link);
>              break;
>          }
>          item = item->u.cache_data.next;
> @@ -64,7 +64,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, RedCacheItem *item)
>      RedCacheItem **now;
>      spice_assert(item);
>  
> -    now = &channel_client->CACHE_NAME[CACHE_HASH_KEY(item->id)];
> +    now = &channel_client->priv->CACHE_NAME[CACHE_HASH_KEY(item->id)];
>      for (;;) {
>          spice_assert(*now);
>          if (*now == item) {
> @@ -74,8 +74,8 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, RedCacheItem *item)
>          now = &(*now)->u.cache_data.next;
>      }
>      ring_remove(&item->u.cache_data.lru_link);
> -    channel_client->VAR_NAME(items)--;
> -    channel_client->VAR_NAME(available) += item->u.cache_data.size;
> +    channel_client->priv->VAR_NAME(items)--;
> +    channel_client->priv->VAR_NAME(available) += item->u.cache_data.size;
>  
>      red_pipe_item_init(&item->u.pipe_data, RED_PIPE_ITEM_TYPE_INVAL_ONE);
>      red_channel_client_pipe_add_tail_and_push(&channel_client->base, &item->u.pipe_data); // for now
> @@ -88,22 +88,22 @@ static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t siz
>  
>      item = spice_new(RedCacheItem, 1);
>  
> -    channel_client->VAR_NAME(available) -= size;
> +    channel_client->priv->VAR_NAME(available) -= size;
>      verify(SPICE_OFFSETOF(RedCacheItem, u.cache_data.lru_link) == 0);
> -    while (channel_client->VAR_NAME(available) < 0) {
> -        RedCacheItem *tail = (RedCacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
> +    while (channel_client->priv->VAR_NAME(available) < 0) {
> +        RedCacheItem *tail = (RedCacheItem *)ring_get_tail(&channel_client->priv->VAR_NAME(lru));
>          if (!tail) {
> -            channel_client->VAR_NAME(available) += size;
> +            channel_client->priv->VAR_NAME(available) += size;
>              free(item);
>              return FALSE;
>          }
>          FUNC_NAME(remove)(channel_client, tail);
>      }
> -    ++channel_client->VAR_NAME(items);
> -    item->u.cache_data.next = channel_client->CACHE_NAME[(key = CACHE_HASH_KEY(id))];
> -    channel_client->CACHE_NAME[key] = item;
> +    ++channel_client->priv->VAR_NAME(items);
> +    item->u.cache_data.next = channel_client->priv->CACHE_NAME[(key = CACHE_HASH_KEY(id))];
> +    channel_client->priv->CACHE_NAME[key] = item;
>      ring_item_init(&item->u.cache_data.lru_link);
> -    ring_add(&channel_client->VAR_NAME(lru), &item->u.cache_data.lru_link);
> +    ring_add(&channel_client->priv->VAR_NAME(lru), &item->u.cache_data.lru_link);
>      item->id = id;
>      item->u.cache_data.size = size;
>      return TRUE;
> @@ -114,15 +114,15 @@ static void FUNC_NAME(reset)(CHANNELCLIENT *channel_client, long size)
>      int i;
>  
>      for (i = 0; i < CACHE_HASH_SIZE; i++) {
> -        while (channel_client->CACHE_NAME[i]) {
> -            RedCacheItem *item = channel_client->CACHE_NAME[i];
> -            channel_client->CACHE_NAME[i] = item->u.cache_data.next;
> +        while (channel_client->priv->CACHE_NAME[i]) {
> +            RedCacheItem *item = channel_client->priv->CACHE_NAME[i];
> +            channel_client->priv->CACHE_NAME[i] = item->u.cache_data.next;
>              free(item);
>          }
>      }
> -    ring_init(&channel_client->VAR_NAME(lru));
> -    channel_client->VAR_NAME(available) = size;
> -    channel_client->VAR_NAME(items) = 0;
> +    ring_init(&channel_client->priv->VAR_NAME(lru));
> +    channel_client->priv->VAR_NAME(available) = size;
> +    channel_client->priv->VAR_NAME(items) = 0;
>  }
>  
>  
> diff --git a/server/cursor-channel-client.c b/server/cursor-channel-client.c
> index 8c26d43..dceb2d0 100644
> --- a/server/cursor-channel-client.c
> +++ b/server/cursor-channel-client.c
> @@ -39,9 +39,16 @@ enum {
>      RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
>  };
>  
> -struct CursorChannelClient {
> +typedef struct CursorChannelClientPrivate CursorChannelClientPrivate;
> +struct CursorChannelClient
> +{
>      RedChannelClient base;
>  
> +    CursorChannelClientPrivate *priv;
> +};
> +
> +struct CursorChannelClientPrivate
> +{
>      RedCacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
>      Ring cursor_cache_lru;
>      long cursor_cache_available;
> @@ -99,10 +106,11 @@ CursorChannelClient* cursor_channel_client_new(CursorChannel *cursor, RedClient
>                                                          num_caps,
>                                                          caps);
>      spice_return_val_if_fail(ccc != NULL, NULL);
> +    ccc->priv = g_new0(CursorChannelClientPrivate, 1);
>      COMMON_GRAPHICS_CHANNEL(cursor)->during_target_migrate = mig_target;
>  
> -    ring_init(&ccc->cursor_cache_lru);
> -    ccc->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE;
> +    ring_init(&ccc->priv->cursor_cache_lru);
> +    ccc->priv->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE;
>  
>      return ccc;
>  }
> diff --git a/server/dcc-private.h b/server/dcc-private.h
> index d5aad3f..1c8fe9a 100644
> --- a/server/dcc-private.h
> +++ b/server/dcc-private.h
> @@ -24,9 +24,17 @@
>  #include "stream.h"
>  #include "red-channel-client.h"
>  
> -struct DisplayChannelClient {
> +typedef struct DisplayChannelClientPrivate DisplayChannelClientPrivate;
> +struct DisplayChannelClient
> +{
>      RedChannelClient base;
>      int is_low_bandwidth;

Shouldn't it be on priv too?

  toso

> +
> +    DisplayChannelClientPrivate *priv;
> +};
> +
> +struct DisplayChannelClientPrivate
> +{
>      uint32_t id;
>      SpiceImageCompression image_compression;
>      spice_wan_compression_t jpeg_state;
> diff --git a/server/dcc-send.c b/server/dcc-send.c
> index 032fb0f..d6b9b41 100644
> --- a/server/dcc-send.c
> +++ b/server/dcc-send.c
> @@ -51,7 +51,7 @@ typedef struct BitmapData {
>  
>  static int dcc_pixmap_cache_unlocked_hit(DisplayChannelClient *dcc, uint64_t id, int *lossy)
>  {
> -    PixmapCache *cache = dcc->pixmap_cache;
> +    PixmapCache *cache = dcc->priv->pixmap_cache;
>      NewCacheItem *item;
>      uint64_t serial;
>  
> @@ -62,9 +62,9 @@ static int dcc_pixmap_cache_unlocked_hit(DisplayChannelClient *dcc, uint64_t id,
>          if (item->id == id) {
>              ring_remove(&item->lru_link);
>              ring_add(&cache->lru, &item->lru_link);
> -            spice_assert(dcc->id < MAX_CACHE_CLIENTS);
> -            item->sync[dcc->id] = serial;
> -            cache->sync[dcc->id] = serial;
> +            spice_assert(dcc->priv->id < MAX_CACHE_CLIENTS);
> +            item->sync[dcc->priv->id] = serial;
> +            cache->sync[dcc->priv->id] = serial;
>              *lossy = item->lossy;
>              break;
>          }
> @@ -77,7 +77,7 @@ static int dcc_pixmap_cache_unlocked_hit(DisplayChannelClient *dcc, uint64_t id,
>  static int dcc_pixmap_cache_hit(DisplayChannelClient *dcc, uint64_t id, int *lossy)
>  {
>      int hit;
> -    PixmapCache *cache = dcc->pixmap_cache;
> +    PixmapCache *cache = dcc->priv->pixmap_cache;
>  
>      pthread_mutex_lock(&cache->lock);
>      hit = dcc_pixmap_cache_unlocked_hit(dcc, id, lossy);
> @@ -97,7 +97,7 @@ static int is_surface_area_lossy(DisplayChannelClient *dcc, uint32_t surface_id,
>      spice_return_val_if_fail(validate_surface(display, surface_id), FALSE);
>  
>      surface = &display->surfaces[surface_id];
> -    surface_lossy_region = &dcc->surface_client_lossy_region[surface_id];
> +    surface_lossy_region = &dcc->priv->surface_client_lossy_region[surface_id];
>  
>      if (!area) {
>          if (region_is_empty(surface_lossy_region)) {
> @@ -207,7 +207,7 @@ static void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
>                                                image->descriptor.width * image->descriptor.height,
>                                                is_lossy)) {
>                  io_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
> -                dcc->send_data.pixmap_cache_items[dcc->send_data.num_pixmap_cache_items++] =
> +                dcc->priv->send_data.pixmap_cache_items[dcc->priv->send_data.num_pixmap_cache_items++] =
>                                                                                 image->descriptor.id;
>                  stat_inc_counter(reds, display_channel->add_to_cache_counter, 1);
>              }
> @@ -243,7 +243,7 @@ static void marshal_sub_msg_inval_list_wait(SpiceMarshaller *m,
>  static void send_free_list_legacy(RedChannelClient *rcc)
>  {
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> -    FreeList *free_list = &dcc->send_data.free_list;
> +    FreeList *free_list = &dcc->priv->send_data.free_list;
>      SpiceMarshaller *marshaller;
>      int sub_list_len = 1;
>      SpiceMarshaller *wait_m = NULL;
> @@ -274,7 +274,7 @@ static void send_free_list_legacy(RedChannelClient *rcc)
>  static void send_free_list(RedChannelClient *rcc)
>  {
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> -    FreeList *free_list = &dcc->send_data.free_list;
> +    FreeList *free_list = &dcc->priv->send_data.free_list;
>      int sub_list_len = 1;
>      SpiceMarshaller *urgent_marshaller;
>      SpiceMarshaller *wait_m = NULL;
> @@ -285,14 +285,14 @@ static void send_free_list(RedChannelClient *rcc)
>      int i;
>  
>      urgent_marshaller = red_channel_client_switch_to_urgent_sender(rcc);
> -    for (i = 0; i < dcc->send_data.num_pixmap_cache_items; i++) {
> +    for (i = 0; i < dcc->priv->send_data.num_pixmap_cache_items; i++) {
>          int dummy;
>          /* When using the urgent marshaller, the serial number of the message that is
>           * going to be sent right after the SPICE_MSG_LIST, is increased by one.
>           * But all this message pixmaps cache references used its old serial.
>           * we use pixmap_cache_items to collect these pixmaps, and we update their serial
>           * by calling pixmap_cache_hit. */
> -        dcc_pixmap_cache_hit(dcc, dcc->send_data.pixmap_cache_items[i], &dummy);
> +        dcc_pixmap_cache_hit(dcc, dcc->priv->send_data.pixmap_cache_items[i], &dummy);
>      }
>  
>      if (free_list->wait.header.wait_count) {
> @@ -378,13 +378,13 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>      if (simage->descriptor.flags & SPICE_IMAGE_FLAGS_HIGH_BITS_SET) {
>          image.descriptor.flags = SPICE_IMAGE_FLAGS_HIGH_BITS_SET;
>      }
> -    pthread_mutex_lock(&dcc->pixmap_cache->lock);
> +    pthread_mutex_lock(&dcc->priv->pixmap_cache->lock);
>  
>      if ((simage->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) {
>          int lossy_cache_item;
>          if (dcc_pixmap_cache_unlocked_hit(dcc, image.descriptor.id, &lossy_cache_item)) {
> -            dcc->send_data.pixmap_cache_items[dcc->send_data.num_pixmap_cache_items++] =
> -                                                                               image.descriptor.id;
> +            dcc->priv->send_data.pixmap_cache_items[dcc->priv->send_data.num_pixmap_cache_items++] =
> +                image.descriptor.id;
>              if (can_lossy || !lossy_cache_item) {
>                  if (!display->enable_jpeg || lossy_cache_item) {
>                      image.descriptor.type = SPICE_IMAGE_TYPE_FROM_CACHE;
> @@ -399,10 +399,10 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>                  spice_assert(bitmap_palette_out == NULL);
>                  spice_assert(lzplt_palette_out == NULL);
>                  stat_inc_counter(reds, display->cache_hits_counter, 1);
> -                pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +                pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>                  return FILL_BITS_TYPE_CACHE;
>              } else {
> -                pixmap_cache_unlocked_set_lossy(dcc->pixmap_cache, simage->descriptor.id,
> +                pixmap_cache_unlocked_set_lossy(dcc->priv->pixmap_cache, simage->descriptor.id,
>                                                  FALSE);
>                  image.descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME;
>              }
> @@ -417,7 +417,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>          surface_id = simage->u.surface.surface_id;
>          if (!validate_surface(display, surface_id)) {
>              spice_warning("Invalid surface in SPICE_IMAGE_TYPE_SURFACE");
> -            pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +            pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>              return FILL_BITS_TYPE_SURFACE;
>          }
>  
> @@ -432,7 +432,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>                               &bitmap_palette_out, &lzplt_palette_out);
>          spice_assert(bitmap_palette_out == NULL);
>          spice_assert(lzplt_palette_out == NULL);
> -        pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +        pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>          return FILL_BITS_TYPE_SURFACE;
>      }
>      case SPICE_IMAGE_TYPE_BITMAP: {
> @@ -464,7 +464,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>              }
>  
>              spice_marshaller_add_ref_chunks(m, bitmap->data);
> -            pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +            pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>              return FILL_BITS_TYPE_BITMAP;
>          } else {
>              red_display_add_image_to_pixmap_cache(rcc, simage, &image,
> @@ -482,7 +482,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>              }
>  
>              spice_assert(!comp_send_data.is_lossy || can_lossy);
> -            pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +            pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>              return (comp_send_data.is_lossy ? FILL_BITS_TYPE_COMPRESS_LOSSY :
>                                                FILL_BITS_TYPE_COMPRESS_LOSSLESS);
>          }
> @@ -496,12 +496,12 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>          spice_assert(bitmap_palette_out == NULL);
>          spice_assert(lzplt_palette_out == NULL);
>          spice_marshaller_add_ref_chunks(m, image.u.quic.data);
> -        pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +        pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>          return FILL_BITS_TYPE_COMPRESS_LOSSLESS;
>      default:
>          spice_error("invalid image type %u", image.descriptor.type);
>      }
> -    pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +    pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>      return FILL_BITS_TYPE_INVALID;
>  }
>  
> @@ -511,12 +511,12 @@ static void fill_mask(RedChannelClient *rcc, SpiceMarshaller *m,
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>  
>      if (mask_bitmap && m) {
> -        if (dcc->image_compression != SPICE_IMAGE_COMPRESSION_OFF) {
> +        if (dcc->priv->image_compression != SPICE_IMAGE_COMPRESSION_OFF) {
>              /* todo: pass compression argument */
> -            SpiceImageCompression save_img_comp = dcc->image_compression;
> -            dcc->image_compression = SPICE_IMAGE_COMPRESSION_OFF;
> +            SpiceImageCompression save_img_comp = dcc->priv->image_compression;
> +            dcc->priv->image_compression = SPICE_IMAGE_COMPRESSION_OFF;
>              fill_bits(dcc, m, mask_bitmap, drawable, FALSE);
> -            dcc->image_compression = save_img_comp;
> +            dcc->priv->image_compression = save_img_comp;
>          } else {
>              fill_bits(dcc, m, mask_bitmap, drawable, FALSE);
>          }
> @@ -570,7 +570,7 @@ static void surface_lossy_region_update(DisplayChannelClient *dcc,
>          return;
>      }
>  
> -    surface_lossy_region = &dcc->surface_client_lossy_region[item->surface_id];
> +    surface_lossy_region = &dcc->priv->surface_client_lossy_region[item->surface_id];
>      drawable = item->red_drawable;
>  
>      if (drawable->clip.type == SPICE_CLIP_TYPE_RECTS ) {
> @@ -1707,10 +1707,10 @@ static int red_marshall_stream_data(RedChannelClient *rcc,
>          return FALSE;
>      }
>  
> -    StreamAgent *agent = &dcc->stream_agents[get_stream_id(display, stream)];
> +    StreamAgent *agent = &dcc->priv->stream_agents[get_stream_id(display, stream)];
>      uint64_t time_now = spice_get_monotonic_time_ns();
>  
> -    if (!dcc->use_video_encoder_rate_control) {
> +    if (!dcc->priv->use_video_encoder_rate_control) {
>          if (time_now - agent->last_send_time < (1000 * 1000 * 1000) / agent->fps) {
>              agent->frames--;
>  #ifdef STREAM_STATS
> @@ -1734,7 +1734,7 @@ static int red_marshall_stream_data(RedChannelClient *rcc,
>                                               &outbuf);
>      switch (ret) {
>      case VIDEO_ENCODER_FRAME_DROP:
> -        spice_assert(dcc->use_video_encoder_rate_control);
> +        spice_assert(dcc->priv->use_video_encoder_rate_control);
>  #ifdef STREAM_STATS
>          agent->stats.num_drops_fps++;
>  #endif
> @@ -1812,7 +1812,7 @@ static void display_channel_marshall_migrate_data_surfaces(DisplayChannelClient
>      for (i = 0; i < NUM_SURFACES; i++) {
>          SpiceRect lossy_rect;
>  
> -        if (!dcc->surface_client_created[i]) {
> +        if (!dcc->priv->surface_client_created[i]) {
>              continue;
>          }
>          spice_marshaller_add_uint32(m2, i);
> @@ -1821,7 +1821,7 @@ static void display_channel_marshall_migrate_data_surfaces(DisplayChannelClient
>          if (!lossy) {
>              continue;
>          }
> -        region_extents(&dcc->surface_client_lossy_region[i], &lossy_rect);
> +        region_extents(&dcc->priv->surface_client_lossy_region[i], &lossy_rect);
>          spice_marshaller_add_int32(m2, lossy_rect.left);
>          spice_marshaller_add_int32(m2, lossy_rect.top);
>          spice_marshaller_add_int32(m2, lossy_rect.right);
> @@ -1834,6 +1834,7 @@ static void display_channel_marshall_migrate_data(RedChannelClient *rcc,
>  {
>      DisplayChannel *display_channel;
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> +    ImageEncoders *encoders = dcc_get_encoders(dcc);
>      SpiceMigrateDataDisplay display_data = {0,};
>  
>      display_channel = DCC_TO_DC(dcc);
> @@ -1842,20 +1843,20 @@ static void display_channel_marshall_migrate_data(RedChannelClient *rcc,
>      spice_marshaller_add_uint32(base_marshaller, SPICE_MIGRATE_DATA_DISPLAY_MAGIC);
>      spice_marshaller_add_uint32(base_marshaller, SPICE_MIGRATE_DATA_DISPLAY_VERSION);
>  
> -    spice_assert(dcc->pixmap_cache);
> +    spice_assert(dcc->priv->pixmap_cache);
>      spice_assert(MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS == 4 &&
>                   MIGRATE_DATA_DISPLAY_MAX_CACHE_CLIENTS == MAX_CACHE_CLIENTS);
>  
>      display_data.message_serial = red_channel_client_get_message_serial(rcc);
> -    display_data.low_bandwidth_setting = dcc->is_low_bandwidth;
> +    display_data.low_bandwidth_setting = dcc_is_low_bandwidth(dcc);
>  
> -    display_data.pixmap_cache_freezer = pixmap_cache_freeze(dcc->pixmap_cache);
> -    display_data.pixmap_cache_id = dcc->pixmap_cache->id;
> -    display_data.pixmap_cache_size = dcc->pixmap_cache->size;
> -    memcpy(display_data.pixmap_cache_clients, dcc->pixmap_cache->sync,
> +    display_data.pixmap_cache_freezer = pixmap_cache_freeze(dcc->priv->pixmap_cache);
> +    display_data.pixmap_cache_id = dcc->priv->pixmap_cache->id;
> +    display_data.pixmap_cache_size = dcc->priv->pixmap_cache->size;
> +    memcpy(display_data.pixmap_cache_clients, dcc->priv->pixmap_cache->sync,
>             sizeof(display_data.pixmap_cache_clients));
>  
> -    image_encoders_glz_get_restore_data(&dcc->encoders, &display_data.glz_dict_id,
> +    image_encoders_glz_get_restore_data(encoders, &display_data.glz_dict_id,
>                                          &display_data.glz_dict_data);
>  
>      /* all data besided the surfaces ref */
> @@ -1873,7 +1874,7 @@ static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc,
>      PixmapCache *pixmap_cache;
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_WAIT_FOR_CHANNELS, NULL);
> -    pixmap_cache = dcc->pixmap_cache;
> +    pixmap_cache = dcc->priv->pixmap_cache;
>  
>      pthread_mutex_lock(&pixmap_cache->lock);
>  
> @@ -1881,8 +1882,8 @@ static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc,
>      wait.wait_list[0].channel_type = SPICE_CHANNEL_DISPLAY;
>      wait.wait_list[0].channel_id = pixmap_cache->generation_initiator.client;
>      wait.wait_list[0].message_serial = pixmap_cache->generation_initiator.message;
> -    dcc->pixmap_cache_generation = pixmap_cache->generation;
> -    dcc->pending_pixmaps_sync = FALSE;
> +    dcc->priv->pixmap_cache_generation = pixmap_cache->generation;
> +    dcc->priv->pending_pixmaps_sync = FALSE;
>  
>      pthread_mutex_unlock(&pixmap_cache->lock);
>  
> @@ -1891,7 +1892,7 @@ static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc,
>  
>  static void dcc_pixmap_cache_reset(DisplayChannelClient *dcc, SpiceMsgWaitForChannels* sync_data)
>  {
> -    PixmapCache *cache = dcc->pixmap_cache;
> +    PixmapCache *cache = dcc->priv->pixmap_cache;
>      uint8_t wait_count;
>      uint64_t serial;
>      uint32_t i;
> @@ -1900,14 +1901,14 @@ static void dcc_pixmap_cache_reset(DisplayChannelClient *dcc, SpiceMsgWaitForCha
>      pthread_mutex_lock(&cache->lock);
>      pixmap_cache_clear(cache);
>  
> -    dcc->pixmap_cache_generation = ++cache->generation;
> -    cache->generation_initiator.client = dcc->id;
> +    dcc->priv->pixmap_cache_generation = ++cache->generation;
> +    cache->generation_initiator.client = dcc->priv->id;
>      cache->generation_initiator.message = serial;
> -    cache->sync[dcc->id] = serial;
> +    cache->sync[dcc->priv->id] = serial;
>  
>      wait_count = 0;
>      for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
> -        if (cache->sync[i] && i != dcc->id) {
> +        if (cache->sync[i] && i != dcc->priv->id) {
>              sync_data->wait_list[wait_count].channel_type = SPICE_CHANNEL_DISPLAY;
>              sync_data->wait_list[wait_count].channel_id = i;
>              sync_data->wait_list[wait_count++].message_serial = cache->sync[i];
> @@ -1994,7 +1995,7 @@ static void red_marshall_image(RedChannelClient *rcc,
>  
>      int comp_succeeded = dcc_compress_image(dcc, &red_image, &bitmap, NULL, item->can_lossy, &comp_send_data);
>  
> -    surface_lossy_region = &dcc->surface_client_lossy_region[item->surface_id];
> +    surface_lossy_region = &dcc->priv->surface_client_lossy_region[item->surface_id];
>      if (comp_succeeded) {
>          spice_marshall_Image(src_bitmap_out, &red_image,
>                               &bitmap_palette_out, &lzplt_palette_out);
> @@ -2261,7 +2262,7 @@ static void marshall_surface_create(RedChannelClient *rcc,
>  {
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>  
> -    region_init(&dcc->surface_client_lossy_region[surface_create->surface_id]);
> +    region_init(&dcc->priv->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);
> @@ -2273,7 +2274,7 @@ static void marshall_surface_destroy(RedChannelClient *rcc,
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>      SpiceMsgSurfaceDestroy surface_destroy;
>  
> -    region_destroy(&dcc->surface_client_lossy_region[surface_id]);
> +    region_destroy(&dcc->priv->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;
> @@ -2313,7 +2314,7 @@ static void marshall_stream_activate_report(RedChannelClient *rcc,
>                                              uint32_t stream_id)
>  {
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> -    StreamAgent *agent = &dcc->stream_agents[stream_id];
> +    StreamAgent *agent = &dcc->priv->stream_agents[stream_id];
>      SpiceMsgDisplayStreamActivateReport msg;
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_ACTIVATE_REPORT, NULL);
> @@ -2354,14 +2355,14 @@ static void marshall_gl_draw(RedChannelClient *rcc,
>  static void begin_send_message(RedChannelClient *rcc)
>  {
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> -    FreeList *free_list = &dcc->send_data.free_list;
> +    FreeList *free_list = &dcc->priv->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->id && free_list->sync[i] != 0) {
> +            if (i != dcc->priv->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];
> @@ -2380,9 +2381,10 @@ static void begin_send_message(RedChannelClient *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));
> +    dcc->priv->send_data.free_list.res->count = 0;
> +    dcc->priv->send_data.num_pixmap_cache_items = 0;
> +    memset(dcc->priv->send_data.free_list.sync, 0,
> +           sizeof(dcc->priv->send_data.free_list.sync));
>  }
>  
>  void dcc_send_item(RedChannelClient *rcc, RedPipeItem *pipe_item)
> diff --git a/server/dcc.c b/server/dcc.c
> index 87ef145..9972d75 100644
> --- a/server/dcc.c
> +++ b/server/dcc.c
> @@ -154,7 +154,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
>  
>      /* don't send redundant create surface commands to client */
>      if (!dcc || display->common.during_target_migrate ||
> -        dcc->surface_client_created[surface_id]) {
> +        dcc->priv->surface_client_created[surface_id]) {
>          return;
>      }
>      surface = &display->surfaces[surface_id];
> @@ -162,7 +162,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
>                                           surface_id, surface->context.width,
>                                           surface->context.height,
>                                           surface->context.format, flags);
> -    dcc->surface_client_created[surface_id] = TRUE;
> +    dcc->priv->surface_client_created[surface_id] = TRUE;
>      red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &create->pipe_item);
>  }
>  
> @@ -264,7 +264,7 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
>  
>          surface_id = drawable->surface_deps[x];
>          if (surface_id != -1) {
> -            if (dcc->surface_client_created[surface_id] == TRUE) {
> +            if (dcc->priv->surface_client_created[surface_id] == TRUE) {
>                  continue;
>              }
>              dcc_create_surface(dcc, surface_id);
> @@ -273,7 +273,7 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
>          }
>      }
>  
> -    if (dcc->surface_client_created[drawable->surface_id] == TRUE) {
> +    if (dcc->priv->surface_client_created[drawable->surface_id] == TRUE) {
>          return;
>      }
>  
> @@ -342,12 +342,12 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc)
>      DisplayChannel *display = DCC_TO_DC(dcc);
>  
>      for (i = 0; i < NUM_STREAMS; i++) {
> -        StreamAgent *agent = &dcc->stream_agents[i];
> +        StreamAgent *agent = &dcc->priv->stream_agents[i];
>          agent->stream = &display->streams_buf[i];
>          region_init(&agent->vis_region);
>          region_init(&agent->clip);
>      }
> -    dcc->use_video_encoder_rate_control =
> +    dcc->priv->use_video_encoder_rate_control =
>          red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT);
>  }
>  
> @@ -371,27 +371,29 @@ DisplayChannelClient *dcc_new(DisplayChannel *display,
>          client, stream, TRUE,
>          num_common_caps, common_caps,
>          num_caps, caps);
> +    dcc->priv = g_new0(DisplayChannelClientPrivate, 1);
> +
>      display->common.during_target_migrate = mig_target;
> -    dcc->id = display->common.qxl->id;
> +    dcc->priv->id = display->common.qxl->id;
>      spice_return_val_if_fail(dcc, NULL);
>      spice_info("New display (client %p) dcc %p stream %p", client, dcc, stream);
>  
> -    ring_init(&dcc->palette_cache_lru);
> -    dcc->palette_cache_available = CLIENT_PALETTE_CACHE_SIZE;
> -    dcc->image_compression = image_compression;
> -    dcc->jpeg_state = jpeg_state;
> -    dcc->zlib_glz_state = zlib_glz_state;
> +    ring_init(&dcc->priv->palette_cache_lru);
> +    dcc->priv->palette_cache_available = CLIENT_PALETTE_CACHE_SIZE;
> +    dcc->priv->image_compression = image_compression;
> +    dcc->priv->jpeg_state = jpeg_state;
> +    dcc->priv->zlib_glz_state = zlib_glz_state;
>      // TODO: tune quality according to bandwidth
> -    dcc->encoders.jpeg_quality = 85;
> +    dcc->priv->encoders.jpeg_quality = 85;
>  
> -    dcc->send_data.free_list.res =
> +    dcc->priv->send_data.free_list.res =
>          spice_malloc(sizeof(SpiceResourceList) +
>                       DISPLAY_FREE_LIST_DEFAULT_SIZE * sizeof(SpiceResourceID));
> -    dcc->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE;
> +    dcc->priv->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE;
>  
>      dcc_init_stream_agents(dcc);
>  
> -    image_encoders_init(&dcc->encoders, &display->encoder_shared_data);
> +    image_encoders_init(&dcc->priv->encoders, &display->encoder_shared_data);
>  
>      return dcc;
>  }
> @@ -410,18 +412,18 @@ static void dcc_create_all_streams(DisplayChannelClient *dcc)
>  /* TODO: this function is evil^Wsynchronous, fix */
>  static int display_channel_client_wait_for_init(DisplayChannelClient *dcc)
>  {
> -    dcc->expect_init = TRUE;
> +    dcc->priv->expect_init = TRUE;
>      uint64_t end_time = spice_get_monotonic_time_ns() + COMMON_CLIENT_TIMEOUT;
>      for (;;) {
>          red_channel_client_receive(RED_CHANNEL_CLIENT(dcc));
>          if (!red_channel_client_is_connected(RED_CHANNEL_CLIENT(dcc))) {
>              break;
>          }
> -        if (dcc->pixmap_cache && dcc->encoders.glz_dict) {
> -            dcc->pixmap_cache_generation = dcc->pixmap_cache->generation;
> +        if (dcc->priv->pixmap_cache && dcc->priv->encoders.glz_dict) {
> +            dcc->priv->pixmap_cache_generation = dcc->priv->pixmap_cache->generation;
>              /* TODO: move common.id? if it's used for a per client structure.. */
> -            spice_info("creating encoder with id == %d", dcc->id);
> -            if (!image_encoders_glz_create(&dcc->encoders, dcc->id)) {
> +            spice_info("creating encoder with id == %d", dcc->priv->id);
> +            if (!image_encoders_glz_create(&dcc->priv->encoders, dcc->priv->id)) {
>                  spice_critical("create global lz failed");
>              }
>              return TRUE;
> @@ -472,7 +474,7 @@ static void dcc_destroy_stream_agents(DisplayChannelClient *dcc)
>      int i;
>  
>      for (i = 0; i < NUM_STREAMS; i++) {
> -        StreamAgent *agent = &dcc->stream_agents[i];
> +        StreamAgent *agent = &dcc->priv->stream_agents[i];
>          region_destroy(&agent->vis_region);
>          region_destroy(&agent->clip);
>          if (agent->video_encoder) {
> @@ -486,14 +488,14 @@ void dcc_stop(DisplayChannelClient *dcc)
>  {
>      DisplayChannel *dc = DCC_TO_DC(dcc);
>  
> -    pixmap_cache_unref(dcc->pixmap_cache);
> -    dcc->pixmap_cache = NULL;
> +    pixmap_cache_unref(dcc->priv->pixmap_cache);
> +    dcc->priv->pixmap_cache = NULL;
>      dcc_palette_cache_reset(dcc);
> -    free(dcc->send_data.free_list.res);
> +    free(dcc->priv->send_data.free_list.res);
>      dcc_destroy_stream_agents(dcc);
> -    image_encoders_free(&dcc->encoders);
> +    image_encoders_free(&dcc->priv->encoders);
>  
> -    if (dcc->gl_draw_ongoing) {
> +    if (dcc->priv->gl_draw_ongoing) {
>          display_channel_gl_draw_done(dc);
>      }
>  }
> @@ -599,7 +601,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
>          return NULL;
>      }
>  
> -    dcc->gl_draw_ongoing = TRUE;
> +    dcc->priv->gl_draw_ongoing = TRUE;
>      item->draw = *draw;
>      red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_DRAW);
>  
> @@ -620,11 +622,11 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
>      channel = RED_CHANNEL(display);
>  
>      if (COMMON_GRAPHICS_CHANNEL(display)->during_target_migrate ||
> -        !dcc->surface_client_created[surface_id]) {
> +        !dcc->priv->surface_client_created[surface_id]) {
>          return;
>      }
>  
> -    dcc->surface_client_created[surface_id] = FALSE;
> +    dcc->priv->surface_client_created[surface_id] = FALSE;
>      destroy = red_surface_destroy_item_new(channel, surface_id);
>      red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &destroy->pipe_item);
>  }
> @@ -725,20 +727,20 @@ int dcc_compress_image(DisplayChannelClient *dcc,
>  
>      stat_start_time_init(&start_time, &display_channel->encoder_shared_data.off_stat);
>  
> -    image_compression = get_compression_for_bitmap(src, dcc->image_compression, drawable);
> +    image_compression = get_compression_for_bitmap(src, dcc->priv->image_compression, drawable);
>      switch (image_compression) {
>      case SPICE_IMAGE_COMPRESSION_OFF:
>          break;
>      case SPICE_IMAGE_COMPRESSION_QUIC:
>          if (can_lossy && display_channel->enable_jpeg &&
>              (src->format != SPICE_BITMAP_FMT_RGBA || !bitmap_has_extra_stride(src))) {
> -            success = image_encoders_compress_jpeg(&dcc->encoders, dest, src, o_comp_data);
> +            success = image_encoders_compress_jpeg(&dcc->priv->encoders, dest, src, o_comp_data);
>              break;
>          }
> -        success = image_encoders_compress_quic(&dcc->encoders, dest, src, o_comp_data);
> +        success = image_encoders_compress_quic(&dcc->priv->encoders, dest, src, o_comp_data);
>          break;
>      case SPICE_IMAGE_COMPRESSION_GLZ:
> -        success = image_encoders_compress_glz(&dcc->encoders, dest, src,
> +        success = image_encoders_compress_glz(&dcc->priv->encoders, dest, src,
>                                                drawable->red_drawable, &drawable->glz_retention,
>                                                o_comp_data,
>                                                display_channel->enable_zlib_glz_wrap);
> @@ -750,13 +752,13 @@ int dcc_compress_image(DisplayChannelClient *dcc,
>      case SPICE_IMAGE_COMPRESSION_LZ4:
>          if (red_channel_client_test_remote_cap(&dcc->base,
>                                                 SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) {
> -            success = image_encoders_compress_lz4(&dcc->encoders, dest, src, o_comp_data);
> +            success = image_encoders_compress_lz4(&dcc->priv->encoders, dest, src, o_comp_data);
>              break;
>          }
>  #endif
>  lz_compress:
>      case SPICE_IMAGE_COMPRESSION_LZ:
> -        success = image_encoders_compress_lz(&dcc->encoders, dest, src, o_comp_data);
> +        success = image_encoders_compress_lz(&dcc->priv->encoders, dest, src, o_comp_data);
>          if (success && !bitmap_fmt_is_rgb(src->format)) {
>              dcc_palette_cache_palette(dcc, dest->u.lz_plt.palette, &(dest->u.lz_plt.flags));
>          }
> @@ -802,7 +804,7 @@ void dcc_palette_cache_reset(DisplayChannelClient *dcc)
>  static void dcc_push_release(DisplayChannelClient *dcc, uint8_t type, uint64_t id,
>                               uint64_t* sync_data)
>  {
> -    FreeList *free_list = &dcc->send_data.free_list;
> +    FreeList *free_list = &dcc->priv->send_data.free_list;
>      int i;
>  
>      for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
> @@ -827,7 +829,7 @@ static void dcc_push_release(DisplayChannelClient *dcc, uint8_t type, uint64_t i
>  int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
>                                    uint32_t size, int lossy)
>  {
> -    PixmapCache *cache = dcc->pixmap_cache;
> +    PixmapCache *cache = dcc->priv->pixmap_cache;
>      NewCacheItem *item;
>      uint64_t serial;
>      int key;
> @@ -837,11 +839,11 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
>      item = spice_new(NewCacheItem, 1);
>      serial = red_channel_client_get_message_serial(RED_CHANNEL_CLIENT(dcc));
>  
> -    if (cache->generation != dcc->pixmap_cache_generation) {
> -        if (!dcc->pending_pixmaps_sync) {
> +    if (cache->generation != dcc->priv->pixmap_cache_generation) {
> +        if (!dcc->priv->pending_pixmaps_sync) {
>              red_channel_client_pipe_add_type(
>                                               RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_SYNC);
> -            dcc->pending_pixmaps_sync = TRUE;
> +            dcc->priv->pending_pixmaps_sync = TRUE;
>          }
>          free(item);
>          return FALSE;
> @@ -854,7 +856,7 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
>  
>          verify(SPICE_OFFSETOF(NewCacheItem, lru_link) == 0);
>          if (!(tail = (NewCacheItem *)ring_get_tail(&cache->lru)) ||
> -                                                   tail->sync[dcc->id] == serial) {
> +                                                   tail->sync[dcc->priv->id] == serial) {
>              cache->available += size;
>              free(item);
>              return FALSE;
> @@ -872,7 +874,7 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
>          ring_remove(&tail->lru_link);
>          cache->items--;
>          cache->available += tail->size;
> -        cache->sync[dcc->id] = serial;
> +        cache->sync[dcc->priv->id] = serial;
>          dcc_push_release(dcc, SPICE_RES_TYPE_PIXMAP, tail->id, tail->sync);
>          free(tail);
>      }
> @@ -885,8 +887,8 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
>      item->size = size;
>      item->lossy = lossy;
>      memset(item->sync, 0, sizeof(item->sync));
> -    item->sync[dcc->id] = serial;
> -    cache->sync[dcc->id] = serial;
> +    item->sync[dcc->priv->id] = serial;
> +    cache->sync[dcc->priv->id] = serial;
>      return TRUE;
>  }
>  
> @@ -895,16 +897,16 @@ static int dcc_handle_init(DisplayChannelClient *dcc, SpiceMsgcDisplayInit *init
>      gboolean success;
>      RedClient *client = red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc));
>  
> -    spice_return_val_if_fail(dcc->expect_init, FALSE);
> -    dcc->expect_init = FALSE;
> +    spice_return_val_if_fail(dcc->priv->expect_init, FALSE);
> +    dcc->priv->expect_init = FALSE;
>  
> -    spice_return_val_if_fail(!dcc->pixmap_cache, FALSE);
> -    dcc->pixmap_cache = pixmap_cache_get(client,
> -                                         init->pixmap_cache_id,
> -                                         init->pixmap_cache_size);
> -    spice_return_val_if_fail(dcc->pixmap_cache, FALSE);
> +    spice_return_val_if_fail(!dcc->priv->pixmap_cache, FALSE);
> +    dcc->priv->pixmap_cache = pixmap_cache_get(client,
> +                                               init->pixmap_cache_id,
> +                                               init->pixmap_cache_size);
> +    spice_return_val_if_fail(dcc->priv->pixmap_cache, FALSE);
>  
> -    success = image_encoders_get_glz_dictionary(&dcc->encoders,
> +    success = image_encoders_get_glz_dictionary(&dcc->priv->encoders,
>                                                  client,
>                                                  init->glz_dictionary_id,
>                                                  init->glz_dictionary_window_size);
> @@ -924,7 +926,7 @@ static int dcc_handle_stream_report(DisplayChannelClient *dcc,
>          return FALSE;
>      }
>  
> -    agent = &dcc->stream_agents[report->stream_id];
> +    agent = &dcc->priv->stream_agents[report->stream_id];
>      if (!agent->video_encoder) {
>          spice_info("stream_report: no encoder for stream id %u. "
>                     "The stream has probably been destroyed",
> @@ -962,7 +964,7 @@ static int dcc_handle_preferred_compression(DisplayChannelClient *dcc,
>      case SPICE_IMAGE_COMPRESSION_LZ:
>      case SPICE_IMAGE_COMPRESSION_GLZ:
>      case SPICE_IMAGE_COMPRESSION_OFF:
> -        dcc->image_compression = pc->image_compression;
> +        dcc->priv->image_compression = pc->image_compression;
>          break;
>      default:
>          spice_warning("preferred-compression: unsupported image compression setting");
> @@ -974,13 +976,13 @@ static int dcc_handle_gl_draw_done(DisplayChannelClient *dcc)
>  {
>      DisplayChannel *display = DCC_TO_DC(dcc);
>  
> -    if (G_UNLIKELY(!dcc->gl_draw_ongoing)) {
> +    if (G_UNLIKELY(!dcc->priv->gl_draw_ongoing)) {
>          g_warning("unexpected DRAW_DONE received\n");
>          /* close client connection */
>          return FALSE;
>      }
>  
> -    dcc->gl_draw_ongoing = FALSE;
> +    dcc->priv->gl_draw_ongoing = FALSE;
>      display_channel_gl_draw_done(display);
>  
>      return TRUE;
> @@ -1008,7 +1010,7 @@ int dcc_handle_message(RedChannelClient *rcc, uint32_t size, uint16_t type, void
>  static int dcc_handle_migrate_glz_dictionary(DisplayChannelClient *dcc,
>                                               SpiceMigrateDataDisplay *migrate)
>  {
> -    return image_encoders_restore_glz_dictionary(&dcc->encoders,
> +    return image_encoders_restore_glz_dictionary(&dcc->priv->encoders,
>                                                   red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)),
>                                                   migrate->glz_dict_id,
>                                                   &migrate->glz_dict_data);
> @@ -1018,11 +1020,11 @@ static int restore_surface(DisplayChannelClient *dcc, uint32_t surface_id)
>  {
>      /* we don't process commands till we receive the migration data, thus,
>       * we should have not sent any surface to the client. */
> -    if (dcc->surface_client_created[surface_id]) {
> +    if (dcc->priv->surface_client_created[surface_id]) {
>          spice_warning("surface %u is already marked as client_created", surface_id);
>          return FALSE;
>      }
> -    dcc->surface_client_created[surface_id] = TRUE;
> +    dcc->priv->surface_client_created[surface_id] = TRUE;
>      return TRUE;
>  }
>  
> @@ -1060,8 +1062,8 @@ static int restore_surfaces_lossy(DisplayChannelClient *dcc,
>          lossy_rect.top = mig_lossy_rect->top;
>          lossy_rect.right = mig_lossy_rect->right;
>          lossy_rect.bottom = mig_lossy_rect->bottom;
> -        region_init(&dcc->surface_client_lossy_region[surface_id]);
> -        region_add(&dcc->surface_client_lossy_region[surface_id], &lossy_rect);
> +        region_init(&dcc->priv->surface_client_lossy_region[surface_id]);
> +        region_add(&dcc->priv->surface_client_lossy_region[surface_id], &lossy_rect);
>      }
>      return TRUE;
>  }
> @@ -1085,26 +1087,26 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
>       * channel client that froze the cache on the src size receives the migrate
>       * data and unfreezes the cache by setting its size > 0 and by triggering
>       * pixmap_cache_reset */
> -    dcc->pixmap_cache = pixmap_cache_get(red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)),
> -                                         migrate_data->pixmap_cache_id, -1);
> -    spice_return_val_if_fail(dcc->pixmap_cache, FALSE);
> +    dcc->priv->pixmap_cache = pixmap_cache_get(red_channel_client_get_client(RED_CHANNEL_CLIENT(dcc)),
> +                                               migrate_data->pixmap_cache_id, -1);
> +    spice_return_val_if_fail(dcc->priv->pixmap_cache, FALSE);
>  
> -    pthread_mutex_lock(&dcc->pixmap_cache->lock);
> +    pthread_mutex_lock(&dcc->priv->pixmap_cache->lock);
>      for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
> -        dcc->pixmap_cache->sync[i] = MAX(dcc->pixmap_cache->sync[i],
> -                                         migrate_data->pixmap_cache_clients[i]);
> +        dcc->priv->pixmap_cache->sync[i] = MAX(dcc->priv->pixmap_cache->sync[i],
> +                                               migrate_data->pixmap_cache_clients[i]);
>      }
> -    pthread_mutex_unlock(&dcc->pixmap_cache->lock);
> +    pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>  
>      if (migrate_data->pixmap_cache_freezer) {
>          /* activating the cache. The cache will start to be active after
>           * pixmap_cache_reset is called, when handling RED_PIPE_ITEM_TYPE_PIXMAP_RESET */
> -        dcc->pixmap_cache->size = migrate_data->pixmap_cache_size;
> +        dcc->priv->pixmap_cache->size = migrate_data->pixmap_cache_size;
>          red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_RESET);
>      }
>  
>      if (dcc_handle_migrate_glz_dictionary(dcc, migrate_data)) {
> -        image_encoders_glz_create(&dcc->encoders, dcc->id);
> +        image_encoders_glz_create(&dcc->priv->encoders, dcc->priv->id);
>      } else {
>          spice_critical("restoring global lz dictionary failed");
>      }
> @@ -1113,10 +1115,10 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
>  
>      if (migrate_data->low_bandwidth_setting) {
>          red_channel_client_ack_set_client_window(RED_CHANNEL_CLIENT(dcc), WIDE_CLIENT_ACK_WINDOW);
> -        if (dcc->jpeg_state == SPICE_WAN_COMPRESSION_AUTO) {
> +        if (dcc->priv->jpeg_state == SPICE_WAN_COMPRESSION_AUTO) {
>              display->enable_jpeg = TRUE;
>          }
> -        if (dcc->zlib_glz_state == SPICE_WAN_COMPRESSION_AUTO) {
> +        if (dcc->priv->zlib_glz_state == SPICE_WAN_COMPRESSION_AUTO) {
>              display->enable_zlib_glz_wrap = TRUE;
>          }
>      }
> @@ -1136,47 +1138,47 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
>  
>  StreamAgent* dcc_get_stream_agent(DisplayChannelClient *dcc, int stream_id)
>  {
> -    return &dcc->stream_agents[stream_id];
> +    return &dcc->priv->stream_agents[stream_id];
>  }
>  
>  ImageEncoders* dcc_get_encoders(DisplayChannelClient *dcc)
>  {
> -    return &dcc->encoders;
> +    return &dcc->priv->encoders;
>  }
>  
>  spice_wan_compression_t dcc_get_jpeg_state(DisplayChannelClient *dcc)
>  {
> -    return dcc->jpeg_state;
> +    return dcc->priv->jpeg_state;
>  }
>  
>  spice_wan_compression_t dcc_get_zlib_glz_state(DisplayChannelClient *dcc)
>  {
> -    return dcc->zlib_glz_state;
> +    return dcc->priv->zlib_glz_state;
>  }
>  
>  gboolean dcc_use_video_encoder_rate_control(DisplayChannelClient *dcc)
>  {
> -    return dcc->use_video_encoder_rate_control;
> +    return dcc->priv->use_video_encoder_rate_control;
>  }
>  
>  uint32_t dcc_get_max_stream_latency(DisplayChannelClient *dcc)
>  {
> -    return dcc->streams_max_latency;
> +    return dcc->priv->streams_max_latency;
>  }
>  
>  void dcc_set_max_stream_latency(DisplayChannelClient *dcc, uint32_t latency)
>  {
> -    dcc->streams_max_latency = latency;
> +    dcc->priv->streams_max_latency = latency;
>  }
>  
>  uint64_t dcc_get_max_stream_bit_rate(DisplayChannelClient *dcc)
>  {
> -    return dcc->streams_max_bit_rate;
> +    return dcc->priv->streams_max_bit_rate;
>  }
>  
>  void dcc_set_max_stream_bit_rate(DisplayChannelClient *dcc, uint64_t rate)
>  {
> -    dcc->streams_max_bit_rate = rate;
> +    dcc->priv->streams_max_bit_rate = rate;
>  }
>  
>  int dcc_config_socket(RedChannelClient *rcc)
> -- 
> 2.7.4
> 
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel





[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]