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