On Thu, 2016-09-15 at 15:06 -0500, Jonathon Jongsma wrote:
> On Thu, 2016-09-15 at 11:22 -0500, Jonathon Jongsma wrote:
> > Move all of the DisplayChannel data memembers into a private
> > struct
> > to
> > encapsulate things better. This necessitated a few new 'public'
> > methods
> > and a small bit of refactoring to avoid poking into DisplayChannel
> > internals from too many places. The DisplayChannel and the
> > DisplayChannelClient are still far too intertwined to completely
> > avoid
> > accessing private data, so at the moment the private struct is
> > defined
> > in display-channel.h and the DisplayChannelClient implementation
> > still accesses it sometimes.
> > ---
> > server/dcc-send.c | 16 +--
> > server/dcc.c | 33 ++---
> > server/display-channel.c | 314 ++++++++++++++++++++++++--------
> > -----
> > ----------
> > server/display-channel.h | 13 +-
> > server/red-worker.c | 6 +
> > server/stream.c | 53 ++++----
> > 6 files changed, 227 insertions(+), 208 deletions(-)
> >
> > diff --git a/server/dcc-send.c b/server/dcc-send.c
> > index 0afa25c..0635afa 100644
> > --- a/server/dcc-send.c
> > +++ b/server/dcc-send.c
> > @@ -96,7 +96,7 @@ static int
> > is_surface_area_lossy(DisplayChannelClient *dcc, uint32_t
> > surface_id,
> >
> > spice_return_val_if_fail(display_channel_validate_surface(dis
> > pla
> > y, surface_id), FALSE);
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > surface_lossy_region = &dcc->priv-
> > > surface_client_lossy_region[surface_id];
> >
> >
> > if (!area) {
> > @@ -208,13 +208,13 @@ static void
> > red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
> > io_image->descriptor.flags |=
> > SPICE_IMAGE_FLAGS_CACHE_ME;
> > 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);
> >
> > + stat_inc_counter(reds, display_channel->priv-
> > > add_to_cache_counter, 1);
> >
> > }
> > }
> > }
> >
> > if (!(io_image->descriptor.flags &
> > SPICE_IMAGE_FLAGS_CACHE_ME))
> > {
> > - stat_inc_counter(reds, display_channel-
> > >non_cache_counter,
> > 1);
> > + stat_inc_counter(reds, display_channel->priv-
> > > non_cache_counter, 1);
> >
> > }
> > }
> >
> > @@ -385,7 +385,7 @@ static FillBitsType
> > fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
> > 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) {
> > + if (!display->priv->enable_jpeg ||
> > lossy_cache_item)
> > {
> > image.descriptor.type =
> > SPICE_IMAGE_TYPE_FROM_CACHE;
> > } else {
> > // making sure, in multiple monitor scenario,
> > that lossy items that
> > @@ -397,7 +397,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);
> > - stat_inc_counter(reds, display-
> > >cache_hits_counter,
> > 1);
> > + stat_inc_counter(reds, display->priv-
> > > cache_hits_counter, 1);
> >
> > pthread_mutex_unlock(&dcc->priv->pixmap_cache-
> > > lock);
> >
> > return FILL_BITS_TYPE_CACHE;
> > } else {
> > @@ -420,7 +420,7 @@ static FillBitsType
> > fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
> > return FILL_BITS_TYPE_SURFACE;
> > }
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > image.descriptor.type = SPICE_IMAGE_TYPE_SURFACE;
> > image.descriptor.flags = 0;
> > image.descriptor.width = surface->context.width;
> > @@ -1862,7 +1862,7 @@ static void
> > display_channel_marshall_migrate_data(RedChannelClient *rcc,
> > spice_marshaller_add(base_marshaller,
> > (uint8_t *)&display_data,
> > sizeof(display_data) - sizeof(uint32_t));
> > display_channel_marshall_migrate_data_surfaces(dcc,
> > base_marshaller,
> > - display_channe
> > l-
> > > enable_jpeg);
> >
> > + display_channe
> > l-
> > > priv->enable_jpeg);
> >
> > }
> >
> > static void display_channel_marshall_pixmap_sync(RedChannelClient
> > *rcc,
> > @@ -2148,7 +2148,7 @@ static void
> > marshall_qxl_drawable(RedChannelClient *rcc,
> > if (item->stream && red_marshall_stream_data(rcc, m, item)) {
> > return;
> > }
> > - if (display->enable_jpeg)
> > + if (display->priv->enable_jpeg)
> > marshall_lossy_qxl_drawable(rcc, m, dpi);
> > else
> > marshall_lossless_qxl_drawable(rcc, m, dpi);
> > diff --git a/server/dcc.c b/server/dcc.c
> > index 36c9c1d..62e32c4 100644
> > --- a/server/dcc.c
> > +++ b/server/dcc.c
> > @@ -21,6 +21,7 @@
> >
> > #include "dcc-private.h"
> > #include "display-channel.h"
> > +#include "dcc.h"
>
>
> Forgot to remove this change before sending out the patch, but I've
> removed it locally.
>
>
> > #include "red-channel-client-private.h"
> >
> > #define DISPLAY_CLIENT_SHORT_TIMEOUT 15000000000ULL //nano@@
> > -157,7
> > +158,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int
> > surface_id)
> > dcc->priv->surface_client_created[surface_id]) {
> > return;
> > }
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > create = red_surface_create_item_new(RED_CHANNEL(display),
> > surface_id, surface-
> > > context.width,
> >
> > surface->context.height,
> > @@ -174,7 +175,7 @@ RedImageItem
> > *dcc_add_surface_area_image(DisplayChannelClient *dcc,
> > int can_lossy)
> > {
> > DisplayChannel *display = DCC_TO_DC(dcc);
> > - RedSurface *surface = &display->surfaces[surface_id];
> > + RedSurface *surface = &display->priv->surfaces[surface_id];
> > SpiceCanvas *canvas = surface->context.canvas;
> > RedImageItem *item;
> > int stride;
> > @@ -240,7 +241,7 @@ void
> > dcc_push_surface_image(DisplayChannelClient
> > *dcc, int surface_id)
> > }
> >
> > display = DCC_TO_DC(dcc);
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > if (!surface->context.canvas) {
> > return;
> > }
> > @@ -343,7 +344,7 @@ static void
> > dcc_init_stream_agents(DisplayChannelClient *dcc)
> >
> > for (i = 0; i < NUM_STREAMS; i++) {
> > StreamAgent *agent = &dcc->priv->stream_agents[i];
> > - agent->stream = &display->streams_buf[i];
> > + agent->stream = &display->priv->streams_buf[i];
> > region_init(&agent->vis_region);
> > region_init(&agent->clip);
> > }
> > @@ -392,14 +393,14 @@ DisplayChannelClient *dcc_new(DisplayChannel
> > *display,
> >
> > dcc_init_stream_agents(dcc);
> >
> > - image_encoders_init(&dcc->priv->encoders, &display-
> > > encoder_shared_data);
> >
> > + image_encoders_init(&dcc->priv->encoders, &display->priv-
> > > encoder_shared_data);
> >
> >
> > return dcc;
> > }
> >
> > static void dcc_create_all_streams(DisplayChannelClient *dcc)
> > {
> > - Ring *ring = &DCC_TO_DC(dcc)->streams;
> > + Ring *ring = &DCC_TO_DC(dcc)->priv->streams;
> > RingItem *item = ring;
> >
> > while ((item = ring_next(ring, item))) {
> > @@ -451,7 +452,7 @@ void dcc_start(DisplayChannelClient *dcc)
> > return;
> >
> > red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIEN
> > T(d
> > cc));
> > - if (display->surfaces[0].context.canvas) {
> > + if (display->priv->surfaces[0].context.canvas) {
> > display_channel_current_flush(display, 0);
> > red_channel_client_pipe_add_type(rcc,
> > RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
> > dcc_create_surface(dcc, 0);
> > @@ -538,7 +539,7 @@ static RedMonitorsConfigItem
> > *red_monitors_config_item_new(RedChannel* channel,
> > void dcc_push_monitors_config(DisplayChannelClient *dcc)
> > {
> > DisplayChannel *dc = DCC_TO_DC(dcc);
> > - MonitorsConfig *monitors_config = dc->monitors_config;
> > + MonitorsConfig *monitors_config = dc->priv->monitors_config;
> > RedMonitorsConfigItem *mci;
> >
> > if (monitors_config == NULL) {
> > @@ -552,7 +553,7 @@ void
> > dcc_push_monitors_config(DisplayChannelClient *dcc)
> > }
> >
> > mci =
> > red_monitors_config_item_new(red_channel_client_get_channel(RED_CH
> > ANN
> > EL_CLIENT(dcc)),
> > - monitors_config_ref(dc-
> > > monitors_config));
> >
> > + monitors_config_ref(dc-
> > >priv-
> > > monitors_config));
> >
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &mci-
> > > pipe_item);
> >
> > red_channel_client_push(RED_CHANNEL_CLIENT(dcc));
> > }
> > @@ -724,14 +725,14 @@ int dcc_compress_image(DisplayChannelClient
> > *dcc,
> > stat_start_time_t start_time;
> > int success = FALSE;
> >
> > - stat_start_time_init(&start_time, &display_channel-
> > > encoder_shared_data.off_stat);
> >
> > + stat_start_time_init(&start_time, &display_channel->priv-
> > > encoder_shared_data.off_stat);
> >
> >
> > 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 &&
> > + if (can_lossy && display_channel->priv->enable_jpeg &&
> > (src->format != SPICE_BITMAP_FMT_RGBA ||
> > !bitmap_has_extra_stride(src))) {
> > success = image_encoders_compress_jpeg(&dcc->priv-
> > > encoders, dest, src, o_comp_data);
> >
> > break;
> > @@ -742,7 +743,7 @@ int dcc_compress_image(DisplayChannelClient
> > *dcc,
> > 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);
> >
> > + display_channel-
> > >priv-
> > > enable_zlib_glz_wrap);
> >
> > if (success) {
> > break;
> > }
> > @@ -768,7 +769,7 @@ lz_compress:
> >
> > if (!success) {
> > uint64_t image_size = src->stride * src->y;
> > - stat_compress_add(&display_channel-
> > > encoder_shared_data.off_stat, start_time, image_size,
> > > image_size);
> >
> > + stat_compress_add(&display_channel->priv-
> > > encoder_shared_data.off_stat, start_time, image_size,
> > > image_size);
> >
> > }
> >
> > return success;
> > @@ -1115,15 +1116,15 @@ 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_CLIE
> > NT(
> > dcc), WIDE_CLIENT_ACK_WINDOW);
> > if (dcc->priv->jpeg_state == SPICE_WAN_COMPRESSION_AUTO)
> > {
> > - display->enable_jpeg = TRUE;
> > + display->priv->enable_jpeg = TRUE;
> > }
> > if (dcc->priv->zlib_glz_state ==
> > SPICE_WAN_COMPRESSION_AUTO)
> > {
> > - display->enable_zlib_glz_wrap = TRUE;
> > + display->priv->enable_zlib_glz_wrap = TRUE;
> > }
> > }
> >
> > surfaces = (uint8_t *)message + migrate_data-
> > > surfaces_at_client_ptr;
> >
> > - surfaces_restored = display->enable_jpeg ?
> > + surfaces_restored = display->priv->enable_jpeg ?
> > restore_surfaces_lossy(dcc,
> > (MigrateDisplaySurfacesAtClientLossy *)surfaces) :
> > restore_surfaces_lossless(dcc,
> > (MigrateDisplaySurfacesAtClientLossless*)surfaces);
> >
> > diff --git a/server/display-channel.c b/server/display-channel.c
> > index 56bb029..d193925 100644
> > --- a/server/display-channel.c
> > +++ b/server/display-channel.c
> > @@ -30,7 +30,7 @@ uint32_t
> > display_channel_generate_uid(DisplayChannel *display)
> > {
> > spice_return_val_if_fail(display != NULL, 0);
> >
> > - return ++display->bits_unique;
> > + return ++display->priv->bits_unique;
> > }
> >
> > #define stat_start(stat,
> > var) \
> > @@ -40,7 +40,7 @@ void
> > display_channel_compress_stats_reset(DisplayChannel *display)
> > {
> > spice_return_if_fail(display);
> >
> > - image_encoder_shared_stat_reset(&display-
> > >encoder_shared_data);
> > + image_encoder_shared_stat_reset(&display->priv-
> > > encoder_shared_data);
> >
> > }
> >
> > void display_channel_compress_stats_print(const DisplayChannel
> > *display_channel)
> > @@ -49,7 +49,7 @@ void display_channel_compress_stats_print(const
> > DisplayChannel *display_channel)
> > spice_return_if_fail(display_channel);
> >
> > spice_info("==> Compression stats for display %u",
> > display_channel->common.base.id);
> > - image_encoder_shared_stat_print(&display_channel-
> > > encoder_shared_data);
> >
> > + image_encoder_shared_stat_print(&display_channel->priv-
> > > encoder_shared_data);
> >
> > #endif
> > }
> >
> > @@ -101,7 +101,7 @@ MonitorsConfig* monitors_config_new(QXLHead
> > *heads, ssize_t nheads, ssize_t max)
> > int display_channel_get_streams_timeout(DisplayChannel *display)
> > {
> > int timeout = INT_MAX;
> > - Ring *ring = &display->streams;
> > + Ring *ring = &display->priv->streams;
> > RingItem *item = ring;
> >
> > red_time_t now = spice_get_monotonic_time_ns();
> > @@ -139,20 +139,20 @@ void
> > display_channel_set_stream_video(DisplayChannel *display, int
> > stream_video)
> > return;
> > }
> >
> > - display->stream_video = stream_video;
> > + display->priv->stream_video = stream_video;
> > }
> >
> > void display_channel_set_video_codecs(DisplayChannel *display,
> > GArray *video_codecs)
> > {
> > spice_return_if_fail(display);
> >
> > - g_array_unref(display->video_codecs);
> > - display->video_codecs = g_array_ref(video_codecs);
> > + g_array_unref(display->priv->video_codecs);
> > + display->priv->video_codecs = g_array_ref(video_codecs);
> > }
> >
> > static void stop_streams(DisplayChannel *display)
> > {
> > - Ring *ring = &display->streams;
> > + Ring *ring = &display->priv->streams;
> > RingItem *item = ring_get_head(ring);
> >
> > while (item) {
> > @@ -165,13 +165,13 @@ static void stop_streams(DisplayChannel
> > *display)
> > }
> > }
> >
> > - display->next_item_trace = 0;
> > - memset(display->items_trace, 0, sizeof(display-
> > >items_trace));
> > + display->priv->next_item_trace = 0;
> > + memset(display->priv->items_trace, 0, sizeof(display->priv-
> > > items_trace));
> >
> > }
> >
> > void display_channel_surface_unref(DisplayChannel *display,
> > uint32_t
> > surface_id)
> > {
> > - RedSurface *surface = &display->surfaces[surface_id];
> > + RedSurface *surface = &display->priv->surfaces[surface_id];
> > QXLInstance *qxl = display->common.qxl;
> > DisplayChannelClient *dcc;
> > GList *link, *next;
> > @@ -207,7 +207,7 @@ void
> > display_channel_surface_unref(DisplayChannel
> > *display, uint32_t surface_id)
> > bool display_channel_surface_has_canvas(DisplayChannel *display,
> > uint32_t surface_id)
> > {
> > - return display->surfaces[surface_id].context.canvas != NULL;
> > + return display->priv->surfaces[surface_id].context.canvas !=
> > NULL;
> > }
> >
> > static void streams_update_visible_region(DisplayChannel
> > *display,
> > Drawable *drawable)
> > @@ -225,7 +225,7 @@ static void
> > streams_update_visible_region(DisplayChannel *display, Drawable
> > *dra
> > return;
> > }
> >
> > - ring = &display->streams;
> > + ring = &display->priv->streams;
> > item = ring_get_head(ring);
> >
> > while (item) {
> > @@ -301,11 +301,11 @@ static void
> > current_add_drawable(DisplayChannel
> > *display,
> > RedSurface *surface;
> > uint32_t surface_id = drawable->surface_id;
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > ring_add_after(&drawable->tree_item.base.siblings_link, pos);
> > - ring_add(&display->current_list, &drawable->list_link);
> > + ring_add(&display->priv->current_list, &drawable->list_link);
> > ring_add(&surface->current_list, &drawable-
> > >surface_list_link);
> > - display->current_size++;
> > + display->priv->current_size++;
> > drawable->refs++;
> > }
> >
> > @@ -318,7 +318,7 @@ static void
> > current_remove_drawable(DisplayChannel *display, Drawable *item)
> > ring_remove(&item->list_link);
> > ring_remove(&item->surface_list_link);
> > drawable_unref(item);
> > - display->current_size--;
> > + display->priv->current_size--;
> > }
> >
> > static void drawable_remove_from_pipes(Drawable *drawable)
> > @@ -375,7 +375,7 @@ static void current_remove(DisplayChannel
> > *display, TreeItem *item)
> >
> > static void current_remove_all(DisplayChannel *display, int
> > surface_id)
> > {
> > - Ring *ring = &display->surfaces[surface_id].current;
> > + Ring *ring = &display->priv->surfaces[surface_id].current;
> > RingItem *ring_item;
> >
> > while ((ring_item = ring_get_head(ring))) {
> > @@ -470,7 +470,7 @@ static void __exclude_region(DisplayChannel
> > *display, Ring *ring, TreeItem *item
> > Ring **top_ring, Drawable
> > *frame_candidate)
> > {
> > QRegion and_rgn;
> > - stat_start(&display->__exclude_stat, start_time);
> > + stat_start(&display->priv->__exclude_stat, start_time);
> >
> > region_clone(&and_rgn, rgn);
> > region_and(&and_rgn, &item->rgn);
> > @@ -532,14 +532,14 @@ static void __exclude_region(DisplayChannel
> > *display, Ring *ring, TreeItem *item
> > }
> > }
> > region_destroy(&and_rgn);
> > - stat_add(&display->__exclude_stat, start_time);
> > + stat_add(&display->priv->__exclude_stat, start_time);
> > }
> >
> > static void exclude_region(DisplayChannel *display, Ring *ring,
> > RingItem *ring_item,
> > QRegion *rgn, TreeItem **last,
> > Drawable
> > *frame_candidate)
> > {
> > Ring *top_ring;
> > - stat_start(&display->exclude_stat, start_time);
> > + stat_start(&display->priv->exclude_stat, start_time);
> >
> > if (!ring_item) {
> > return;
> > @@ -575,7 +575,7 @@ static void exclude_region(DisplayChannel
> > *display, Ring *ring, RingItem *ring_i
> > }
> >
> > if (region_is_empty(rgn)) {
> > - stat_add(&display->exclude_stat, start_time);
> > + stat_add(&display->priv->exclude_stat,
> > start_time);
> > return;
> > }
> > }
> > @@ -584,7 +584,7 @@ static void exclude_region(DisplayChannel
> > *display, Ring *ring, RingItem *ring_i
> > while ((last && *last == (TreeItem *)ring_item) ||
> > !(ring_item = ring_next(ring, ring_item))) {
> > if (ring == top_ring) {
> > - stat_add(&display->exclude_stat, start_time);
> > + stat_add(&display->priv->exclude_stat,
> > start_time);
> > return;
> > }
> > ring_item = &container->base.siblings_link;
> > @@ -596,9 +596,9 @@ static void exclude_region(DisplayChannel
> > *display, Ring *ring, RingItem *ring_i
> >
> > static int current_add_with_shadow(DisplayChannel *display, Ring
> > *ring, Drawable *item)
> > {
> > - stat_start(&display->add_stat, start_time);
> > + stat_start(&display->priv->add_stat, start_time);
> > #ifdef RED_WORKER_STAT
> > - ++display->add_with_shadow_count;
> > + ++display->priv->add_with_shadow_count;
> > #endif
> >
> > RedDrawable *red_drawable = item->red_drawable;
> > @@ -609,7 +609,7 @@ static int
> > current_add_with_shadow(DisplayChannel
> > *display, Ring *ring, Drawable
> >
> > Shadow *shadow = shadow_new(&item->tree_item, &delta);
> > if (!shadow) {
> > - stat_add(&display->add_stat, start_time);
> > + stat_add(&display->priv->add_stat, start_time);
> > return FALSE;
> > }
> > // item and his shadow must initially be placed in the same
> > container.
> > @@ -633,7 +633,7 @@ static int
> > current_add_with_shadow(DisplayChannel
> > *display, Ring *ring, Drawable
> > stream_detach_behind(display, &item-
> > >tree_item.base.rgn,
> > item);
> > }
> > }
> > - stat_add(&display->add_stat, start_time);
> > + stat_add(&display->priv->add_stat, start_time);
> > return TRUE;
> > }
> >
> > @@ -643,7 +643,7 @@ static int current_add(DisplayChannel
> > *display,
> > Ring *ring, Drawable *drawable)
> > RingItem *now;
> > QRegion exclude_rgn;
> > RingItem *exclude_base = NULL;
> > - stat_start(&display->add_stat, start_time);
> > + stat_start(&display->priv->add_stat, start_time);
> >
> > spice_assert(!region_is_empty(&item->base.rgn));
> > region_init(&exclude_rgn);
> > @@ -665,7 +665,7 @@ static int current_add(DisplayChannel
> > *display,
> > Ring *ring, Drawable *drawable)
> > if (!(test_res & REGION_TEST_RIGHT_EXCLUSIVE) &&
> > !(test_res &
> > REGION_TEST_LEFT_EXCLUSIVE) &&
> > current_add_eq
> > ual
> > (display, item, sibling)) {
> > - stat_add(&display->add_stat, start_time);
> > + stat_add(&display->priv->add_stat, start_time);
> > return FALSE;
> > }
> >
> > @@ -751,7 +751,7 @@ static int current_add(DisplayChannel
> > *display,
> > Ring *ring, Drawable *drawable)
> > }
> > }
> > region_destroy(&exclude_rgn);
> > - stat_add(&display->add_stat, start_time);
> > + stat_add(&display->priv->add_stat, start_time);
> > return TRUE;
> > }
> >
> > @@ -760,7 +760,7 @@ static bool drawable_can_stream(DisplayChannel
> > *display, Drawable *drawable)
> > RedDrawable *red_drawable = drawable->red_drawable;
> > SpiceImage *image;
> >
> > - if (display->stream_video == SPICE_STREAM_VIDEO_OFF) {
> > + if (display->priv->stream_video == SPICE_STREAM_VIDEO_OFF) {
> > return FALSE;
> > }
> >
> > @@ -780,7 +780,7 @@ static bool drawable_can_stream(DisplayChannel
> > *display, Drawable *drawable)
> > return FALSE;
> > }
> >
> > - if (display->stream_video == SPICE_STREAM_VIDEO_FILTER) {
> > + if (display->priv->stream_video == SPICE_STREAM_VIDEO_FILTER)
> > {
> > SpiceRect* rect;
> > int size;
> >
> > @@ -797,26 +797,26 @@ static bool
> > drawable_can_stream(DisplayChannel
> > *display, Drawable *drawable)
> > #ifdef RED_WORKER_STAT
> > static void display_channel_print_stats(DisplayChannel *display)
> > {
> > - stat_time_t total = display->add_stat.total;
> > + stat_time_t total = display->priv->add_stat.total;
> > spice_info("add with shadow count %u",
> > - display->add_with_shadow_count);
> > - display->add_with_shadow_count = 0;
> > + display->priv->add_with_shadow_count);
> > + display->priv->add_with_shadow_count = 0;
> > spice_info("add[%u] %f exclude[%u] %f __exclude[%u] %f",
> > - display->add_stat.count,
> > + display->priv->add_stat.count,
> > stat_cpu_time_to_sec(total),
> > - display->exclude_stat.count,
> > - stat_cpu_time_to_sec(display->exclude_stat.total),
> > - display->__exclude_stat.count,
> > - stat_cpu_time_to_sec(display-
> > >__exclude_stat.total));
> > + display->priv->exclude_stat.count,
> > + stat_cpu_time_to_sec(display->priv-
> > > exclude_stat.total),
> >
> > + display->priv->__exclude_stat.count,
> > + stat_cpu_time_to_sec(display->priv-
> > > __exclude_stat.total));
> >
> > spice_info("add %f%% exclude %f%% exclude2 %f%% __exclude
> > %f%%",
> > - (double)(total - display->exclude_stat.total) /
> > total
> > * 100,
> > - (double)(display->exclude_stat.total) / total *
> > 100,
> > - (double)(display->exclude_stat.total -
> > - display->__exclude_stat.total) / display-
> > > exclude_stat.total * 100,
> >
> > - (double)(display->__exclude_stat.total) / display-
> > > exclude_stat.total * 100);
> >
> > - stat_reset(&display->add_stat);
> > - stat_reset(&display->exclude_stat);
> > - stat_reset(&display->__exclude_stat);
> > + (double)(total - display->priv-
> > >exclude_stat.total) /
> > total * 100,
> > + (double)(display->priv->exclude_stat.total) /
> > total *
> > 100,
> > + (double)(display->priv->exclude_stat.total -
> > + display->priv->__exclude_stat.total) /
> > display->priv->exclude_stat.total * 100,
> > + (double)(display->priv->__exclude_stat.total) /
> > display->priv->exclude_stat.total * 100);
> > + stat_reset(&display->priv->add_stat);
> > + stat_reset(&display->priv->exclude_stat);
> > + stat_reset(&display->priv->__exclude_stat);
> > }
> > #endif
> >
> > @@ -831,7 +831,7 @@ static void
> > drawable_ref_surface_deps(DisplayChannel *display, Drawable
> > *drawabl
> > if (surface_id == -1) {
> > continue;
> > }
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > surface->refs++;
> > }
> > }
> > @@ -840,7 +840,7 @@ static void surface_read_bits(DisplayChannel
> > *display, int surface_id,
> > const SpiceRect *area, uint8_t
> > *dest,
> > int dest_stride)
> > {
> > SpiceCanvas *canvas;
> > - RedSurface *surface = &display->surfaces[surface_id];
> > + RedSurface *surface = &display->priv->surfaces[surface_id];
> >
> > canvas = surface->context.canvas;
> > canvas->ops->read_bits(canvas, dest, dest_stride, area);
> > @@ -858,7 +858,7 @@ static void handle_self_bitmap(DisplayChannel
> > *display, Drawable *drawable)
> > int bpp;
> > int all_set;
> >
> > - surface = &display->surfaces[drawable->surface_id];
> > + surface = &display->priv->surfaces[drawable->surface_id];
> >
> > bpp = SPICE_SURFACE_FMT_DEPTH(surface->context.format) / 8;
> > width = red_drawable->self_bitmap_area.right - red_drawable-
> > > self_bitmap_area.left;
> >
> > @@ -910,7 +910,7 @@ static void
> > surface_add_reverse_dependency(DisplayChannel *display, int
> > surface_
> > return;
> > }
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> >
> > depend_item->drawable = drawable;
> > ring_add(&surface->depend_on_me, &depend_item->ring_item);
> > @@ -944,7 +944,7 @@ static void draw_depend_on_me(DisplayChannel
> > *display, uint32_t surface_id)
> > RedSurface *surface;
> > RingItem *ring_item;
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> >
> > while ((ring_item = ring_get_tail(&surface->depend_on_me))) {
> > Drawable *drawable;
> > @@ -965,7 +965,7 @@ static int
> > validate_drawable_bbox(DisplayChannel
> > *display, RedDrawable *drawable
> > if (!display_channel_validate_surface(display, drawable-
> > > surface_id)) {
> >
> > return FALSE;
> > }
> > - context = &display->surfaces[surface_id].context;
> > + context = &display->priv->surfaces[surface_id].context;
> >
> > if (drawable->bbox.top < 0)
> > return FALSE;
> > @@ -1019,7 +1019,7 @@ static Drawable
> > *display_channel_get_drawable(DisplayChannel *display, uint8_t e
> > drawable->red_drawable = red_drawable_ref(red_drawable);
> >
> > drawable->surface_id = red_drawable->surface_id;
> > - display->surfaces[drawable->surface_id].refs++;
> > + display->priv->surfaces[drawable->surface_id].refs++;
> >
> > memcpy(drawable->surface_deps, red_drawable->surface_deps,
> > sizeof(drawable->surface_deps));
> > /*
> > @@ -1069,7 +1069,7 @@ static void
> > display_channel_add_drawable(DisplayChannel *display, Drawable
> > *draw
> > return;
> > }
> >
> > - Ring *ring = &display->surfaces[surface_id].current;
> > + Ring *ring = &display->priv->surfaces[surface_id].current;
> > int add_to_pipe;
> > if (has_shadow(red_drawable)) {
> > add_to_pipe = current_add_with_shadow(display, ring,
> > drawable);
> > @@ -1082,7 +1082,7 @@ static void
> > display_channel_add_drawable(DisplayChannel *display, Drawable
> > *draw
> > pipes_add_drawable(display, drawable);
> >
> > #ifdef RED_WORKER_STAT
> > - if ((++display->add_count % 100) == 0)
> > + if ((++display->priv->add_count % 100) == 0)
> > display_channel_print_stats(display);
> > #endif
> > }
> > @@ -1146,7 +1146,7 @@ void
> > display_channel_flush_all_surfaces(DisplayChannel *display)
> > int x;
> >
> > for (x = 0; x < NUM_SURFACES; ++x) {
> > - if (display->surfaces[x].context.canvas) {
> > + if (display->priv->surfaces[x].context.canvas) {
> > display_channel_current_flush(display, x);
> > }
> > }
> > @@ -1178,7 +1178,7 @@ void
> > display_channel_free_glz_drawables(DisplayChannel *display)
> >
> > static bool free_one_drawable(DisplayChannel *display, int
> > force_glz_free)
> > {
> > - RingItem *ring_item = ring_get_tail(&display->current_list);
> > + RingItem *ring_item = ring_get_tail(&display->priv-
> > > current_list);
> >
> > Drawable *drawable;
> > Container *container;
> >
> > @@ -1200,7 +1200,7 @@ static bool free_one_drawable(DisplayChannel
> > *display, int force_glz_free)
> >
> > void display_channel_current_flush(DisplayChannel *display, int
> > surface_id)
> > {
> > - while (!ring_is_empty(&display-
> > > surfaces[surface_id].current_list)) {
> >
> > + while (!ring_is_empty(&display->priv-
> > > surfaces[surface_id].current_list)) {
> >
> > free_one_drawable(display, FALSE);
> > }
> > current_remove_all(display, surface_id);
> > @@ -1212,8 +1212,8 @@ void
> > display_channel_free_some(DisplayChannel
> > *display)
> > DisplayChannelClient *dcc;
> > GList *link, *next;
> >
> > - spice_debug("#draw=%d, #glz_draw=%d", display-
> > >drawable_count,
> > - display->encoder_shared_data.glz_drawable_count);
> > + spice_debug("#draw=%d, #glz_draw=%d", display->priv-
> > > drawable_count,
> >
> > + display->priv-
> > > encoder_shared_data.glz_drawable_count);
> >
> > FOREACH_CLIENT(display, link, next, dcc) {
> > ImageEncoders *encoders = dcc_get_encoders(dcc);
> >
> > @@ -1224,7 +1224,7 @@ void
> > display_channel_free_some(DisplayChannel
> > *display)
> > }
> > }
> >
> > - while (!ring_is_empty(&display->current_list) && n++ <
> > RED_RELEASE_BUNCH_SIZE) {
> > + while (!ring_is_empty(&display->priv->current_list) && n++ <
> > RED_RELEASE_BUNCH_SIZE) {
> > free_one_drawable(display, TRUE);
> > }
> >
> > @@ -1239,29 +1239,29 @@ static Drawable*
> > drawable_try_new(DisplayChannel *display)
> > {
> > Drawable *drawable;
> >
> > - if (!display->free_drawables)
> > + if (!display->priv->free_drawables)
> > return NULL;
> >
> > - drawable = &display->free_drawables->u.drawable;
> > - display->free_drawables = display->free_drawables->u.next;
> > - display->drawable_count++;
> > + drawable = &display->priv->free_drawables->u.drawable;
> > + display->priv->free_drawables = display->priv-
> > >free_drawables-
> > > u.next;
> >
> > + display->priv->drawable_count++;
> >
> > return drawable;
> > }
> >
> > static void drawable_free(DisplayChannel *display, Drawable
> > *drawable)
> > {
> > - ((_Drawable *)drawable)->u.next = display->free_drawables;
> > - display->free_drawables = (_Drawable *)drawable;
> > + ((_Drawable *)drawable)->u.next = display->priv-
> > >free_drawables;
> > + display->priv->free_drawables = (_Drawable *)drawable;
> > }
> >
> > static void drawables_init(DisplayChannel *display)
> > {
> > int i;
> >
> > - display->free_drawables = NULL;
> > + display->priv->free_drawables = NULL;
> > for (i = 0; i < NUM_DRAWABLES; i++) {
> > - drawable_free(display, &display-
> > >drawables[i].u.drawable);
> > + drawable_free(display, &display->priv-
> > > drawables[i].u.drawable);
> >
> > }
> > }
> >
> > @@ -1360,7 +1360,7 @@ void drawable_unref(Drawable *drawable)
> > red_drawable_unref(drawable->red_drawable);
> > }
> > drawable_free(display, drawable);
> > - display->drawable_count--;
> > + display->priv->drawable_count--;
> > }
> >
> > static void drawable_deps_draw(DisplayChannel *display, Drawable
> > *drawable)
> > @@ -1385,11 +1385,11 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> >
> > drawable_deps_draw(display, drawable);
> >
> > - surface = &display->surfaces[drawable->surface_id];
> > + surface = &display->priv->surfaces[drawable->surface_id];
> > canvas = surface->context.canvas;
> > spice_return_if_fail(canvas);
> >
> > - image_cache_aging(&display->image_cache);
> > + image_cache_aging(&display->priv->image_cache);
> >
> > region_add(&surface->draw_dirty_region, &drawable-
> > >red_drawable-
> > > bbox);
> >
> >
> > @@ -1397,8 +1397,8 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_FILL: {
> > SpiceFill fill = drawable->red_drawable->u.fill;
> > SpiceImage img1, img2;
> > - image_cache_localize_brush(&display->image_cache,
> > &fill.brush, &img1);
> > - image_cache_localize_mask(&display->image_cache,
> > &fill.mask,
> > &img2);
> > + image_cache_localize_brush(&display->priv->image_cache,
> > &fill.brush, &img1);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &fill.mask, &img2);
> > canvas->ops->draw_fill(canvas, &drawable->red_drawable-
> > > bbox,
> >
> > &clip, &fill);
> > break;
> > @@ -1406,17 +1406,17 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_OPAQUE: {
> > SpiceOpaque opaque = drawable->red_drawable->u.opaque;
> > SpiceImage img1, img2, img3;
> > - image_cache_localize_brush(&display->image_cache,
> > &opaque.brush, &img1);
> > - image_cache_localize(&display->image_cache,
> > &opaque.src_bitmap, &img2, drawable);
> > - image_cache_localize_mask(&display->image_cache,
> > &opaque.mask, &img3);
> > + image_cache_localize_brush(&display->priv->image_cache,
> > &opaque.brush, &img1);
> > + image_cache_localize(&display->priv->image_cache,
> > &opaque.src_bitmap, &img2, drawable);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &opaque.mask, &img3);
> > canvas->ops->draw_opaque(canvas, &drawable->red_drawable-
> > > bbox, &clip, &opaque);
> >
> > break;
> > }
> > case QXL_DRAW_COPY: {
> > SpiceCopy copy = drawable->red_drawable->u.copy;
> > SpiceImage img1, img2;
> > - image_cache_localize(&display->image_cache,
> > ©.src_bitmap, &img1, drawable);
> > - image_cache_localize_mask(&display->image_cache,
> > ©.mask,
> > &img2);
> > + image_cache_localize(&display->priv->image_cache,
> > ©.src_bitmap, &img1, drawable);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > ©.mask, &img2);
> > canvas->ops->draw_copy(canvas, &drawable->red_drawable-
> > > bbox,
> >
> > &clip, ©);
> > break;
> > @@ -1424,7 +1424,7 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_TRANSPARENT: {
> > SpiceTransparent transparent = drawable->red_drawable-
> > > u.transparent;
> >
> > SpiceImage img1;
> > - image_cache_localize(&display->image_cache,
> > &transparent.src_bitmap, &img1, drawable);
> > + image_cache_localize(&display->priv->image_cache,
> > &transparent.src_bitmap, &img1, drawable);
> > canvas->ops->draw_transparent(canvas,
> > &drawable->red_drawable-
> > >bbox,
> > &clip, &transparent);
> > break;
> > @@ -1432,7 +1432,7 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_ALPHA_BLEND: {
> > SpiceAlphaBlend alpha_blend = drawable->red_drawable-
> > > u.alpha_blend;
> >
> > SpiceImage img1;
> > - image_cache_localize(&display->image_cache,
> > &alpha_blend.src_bitmap, &img1, drawable);
> > + image_cache_localize(&display->priv->image_cache,
> > &alpha_blend.src_bitmap, &img1, drawable);
> > canvas->ops->draw_alpha_blend(canvas,
> > &drawable->red_drawable-
> > >bbox,
> > &clip, &alpha_blend);
> > break;
> > @@ -1445,8 +1445,8 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_BLEND: {
> > SpiceBlend blend = drawable->red_drawable->u.blend;
> > SpiceImage img1, img2;
> > - image_cache_localize(&display->image_cache,
> > &blend.src_bitmap, &img1, drawable);
> > - image_cache_localize_mask(&display->image_cache,
> > &blend.mask, &img2);
> > + image_cache_localize(&display->priv->image_cache,
> > &blend.src_bitmap, &img1, drawable);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &blend.mask, &img2);
> > canvas->ops->draw_blend(canvas, &drawable->red_drawable-
> > > bbox,
> >
> > &clip, &blend);
> > break;
> > @@ -1454,7 +1454,7 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_BLACKNESS: {
> > SpiceBlackness blackness = drawable->red_drawable-
> > > u.blackness;
> >
> > SpiceImage img1;
> > - image_cache_localize_mask(&display->image_cache,
> > &blackness.mask, &img1);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &blackness.mask, &img1);
> > canvas->ops->draw_blackness(canvas,
> > &drawable->red_drawable-
> > >bbox,
> > &clip, &blackness);
> > break;
> > @@ -1462,7 +1462,7 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_WHITENESS: {
> > SpiceWhiteness whiteness = drawable->red_drawable-
> > > u.whiteness;
> >
> > SpiceImage img1;
> > - image_cache_localize_mask(&display->image_cache,
> > &whiteness.mask, &img1);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &whiteness.mask, &img1);
> > canvas->ops->draw_whiteness(canvas,
> > &drawable->red_drawable-
> > >bbox,
> > &clip, &whiteness);
> > break;
> > @@ -1470,7 +1470,7 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_INVERS: {
> > SpiceInvers invers = drawable->red_drawable->u.invers;
> > SpiceImage img1;
> > - image_cache_localize_mask(&display->image_cache,
> > &invers.mask, &img1);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &invers.mask, &img1);
> > canvas->ops->draw_invers(canvas,
> > &drawable->red_drawable->bbox,
> > &clip, &invers);
> > break;
> > @@ -1478,9 +1478,9 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_ROP3: {
> > SpiceRop3 rop3 = drawable->red_drawable->u.rop3;
> > SpiceImage img1, img2, img3;
> > - image_cache_localize_brush(&display->image_cache,
> > &rop3.brush, &img1);
> > - image_cache_localize(&display->image_cache,
> > &rop3.src_bitmap, &img2, drawable);
> > - image_cache_localize_mask(&display->image_cache,
> > &rop3.mask,
> > &img3);
> > + image_cache_localize_brush(&display->priv->image_cache,
> > &rop3.brush, &img1);
> > + image_cache_localize(&display->priv->image_cache,
> > &rop3.src_bitmap, &img2, drawable);
> > + image_cache_localize_mask(&display->priv->image_cache,
> > &rop3.mask, &img3);
> > canvas->ops->draw_rop3(canvas, &drawable->red_drawable-
> > > bbox,
> >
> > &clip, &rop3);
> > break;
> > @@ -1488,9 +1488,9 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_COMPOSITE: {
> > SpiceComposite composite = drawable->red_drawable-
> > > u.composite;
> >
> > SpiceImage src, mask;
> > - image_cache_localize(&display->image_cache,
> > &composite.src_bitmap, &src, drawable);
> > + image_cache_localize(&display->priv->image_cache,
> > &composite.src_bitmap, &src, drawable);
> > if (composite.mask_bitmap)
> > - image_cache_localize(&display->image_cache,
> > &composite.mask_bitmap, &mask, drawable);
> > + image_cache_localize(&display->priv->image_cache,
> > &composite.mask_bitmap, &mask, drawable);
> > canvas->ops->draw_composite(canvas, &drawable-
> > >red_drawable-
> > > bbox,
> >
> > &clip, &composite);
> > break;
> > @@ -1498,7 +1498,7 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_STROKE: {
> > SpiceStroke stroke = drawable->red_drawable->u.stroke;
> > SpiceImage img1;
> > - image_cache_localize_brush(&display->image_cache,
> > &stroke.brush, &img1);
> > + image_cache_localize_brush(&display->priv->image_cache,
> > &stroke.brush, &img1);
> > canvas->ops->draw_stroke(canvas,
> > &drawable->red_drawable->bbox,
> > &clip, &stroke);
> > break;
> > @@ -1506,8 +1506,8 @@ static void drawable_draw(DisplayChannel
> > *display, Drawable *drawable)
> > case QXL_DRAW_TEXT: {
> > SpiceText text = drawable->red_drawable->u.text;
> > SpiceImage img1, img2;
> > - image_cache_localize_brush(&display->image_cache,
> > &text.fore_brush, &img1);
> > - image_cache_localize_brush(&display->image_cache,
> > &text.back_brush, &img2);
> > + image_cache_localize_brush(&display->priv->image_cache,
> > &text.fore_brush, &img1);
> > + image_cache_localize_brush(&display->priv->image_cache,
> > &text.back_brush, &img2);
> > canvas->ops->draw_text(canvas, &drawable->red_drawable-
> > > bbox,
> >
> > &clip, &text);
> > break;
> > @@ -1599,11 +1599,11 @@ void
> > display_channel_draw_until(DisplayChannel *display, const
> > SpiceRect
> > *area,
> > spice_return_if_fail(last);
> > spice_return_if_fail(ring_item_is_linked(&last->list_link));
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> >
> > if (surface_id != last->surface_id) {
> > // find the nearest older drawable from the appropriate
> > surface
> > - ring = &display->current_list;
> > + ring = &display->priv->current_list;
> > ring_item = &last->list_link;
> > while ((ring_item = ring_next(ring, ring_item))) {
> > now = SPICE_CONTAINEROF(ring_item, Drawable,
> > list_link);
> > @@ -1644,7 +1644,7 @@ void display_channel_draw(DisplayChannel
> > *display, const SpiceRect *area, int su
> > spice_return_if_fail(area->left >= 0 && area->top >= 0 &&
> > area->left < area->right && area->top <
> > area->bottom);
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> >
> > last = current_find_intersects_rect(&surface->current_list,
> > NULL, area);
> > if (last)
> > @@ -1681,7 +1681,7 @@ void display_channel_update(DisplayChannel
> > *display,
> > red_get_rect_ptr(&rect, area);
> > display_channel_draw(display, &rect, surface_id);
> >
> > - surface = &display->surfaces[surface_id];
> > + surface = &display->priv->surfaces[surface_id];
> > if (*qxl_dirty_rects == NULL) {
> > *num_dirty_rects = pixman_region32_n_rects(&surface-
> > > draw_dirty_region);
> >
> > *qxl_dirty_rects = spice_new0(QXLRect, *num_dirty_rects);
> > @@ -1721,7 +1721,7 @@ void
> > display_channel_destroy_surface_wait(DisplayChannel *display,
> > uint32_t surf
> > {
> > if (!display_channel_validate_surface(display, surface_id))
> > return;
> > - if (!display->surfaces[surface_id].context.canvas)
> > + if (!display->priv->surfaces[surface_id].context.canvas)
> > return;
> >
> > draw_depend_on_me(display, surface_id);
> > @@ -1741,15 +1741,15 @@ void
> > display_channel_destroy_surfaces(DisplayChannel *display)
> > spice_debug(NULL);
> > //to handle better
> > for (i = 0; i < NUM_SURFACES; ++i) {
> > - if (display->surfaces[i].context.canvas) {
> > + if (display->priv->surfaces[i].context.canvas) {
> > display_channel_destroy_surface_wait(display, i);
> > - if (display->surfaces[i].context.canvas) {
> > + if (display->priv->surfaces[i].context.canvas) {
> > display_channel_surface_unref(display, i);
> > }
> > - spice_assert(!display->surfaces[i].context.canvas);
> > + spice_assert(!display->priv-
> > > surfaces[i].context.canvas);
> >
> > }
> > }
> > - spice_warn_if_fail(ring_is_empty(&display->streams));
> > + spice_warn_if_fail(ring_is_empty(&display->priv->streams));
> >
> > if (red_channel_is_connected(RED_CHANNEL(display))) {
> > red_channel_pipes_add_type(RED_CHANNEL(display),
> > RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
> > @@ -1780,8 +1780,8 @@ create_canvas_for_surface(DisplayChannel
> > *display, RedSurface *surface, uint32_t
> > case RED_RENDERER_SW:
> > canvas = canvas_create_for_data(surface->context.width,
> > surface->context.height, surface->context.format,
> > surface->context.line_0,
> > surface->context.stride,
> > - &display-
> > >image_cache.base,
> > - &display->image_surfaces,
> > NULL, NULL, NULL);
> > + &display->priv-
> > > image_cache.base,
> >
> > + &display->priv-
> > > image_surfaces, NULL, NULL, NULL);
> >
> > surface->context.top_down = TRUE;
> > surface->context.canvas_draws_on_surface = TRUE;
> > return canvas;
> > @@ -1796,7 +1796,7 @@ void
> > display_channel_create_surface(DisplayChannel *display, uint32_t
> > surface_id
> > uint32_t height, int32_t
> > stride,
> > uint32_t format,
> > void *line_0, int
> > data_is_valid,
> > int send_client)
> > {
> > - RedSurface *surface = &display->surfaces[surface_id];
> > + RedSurface *surface = &display->priv->surfaces[surface_id];
> >
> > spice_warn_if_fail(!surface->context.canvas);
> >
> > @@ -1821,7 +1821,7 @@ void
> > display_channel_create_surface(DisplayChannel *display, uint32_t
> > surface_id
> > region_init(&surface->draw_dirty_region);
> > surface->refs = 1;
> >
> > - if (display->renderer == RED_RENDERER_INVALID) {
> > + if (display->priv->renderer == RED_RENDERER_INVALID) {
> > int i;
> > QXLInstance *qxl = display->common.qxl;
> > RedsState *reds = red_qxl_get_server(qxl->st);
> > @@ -1830,12 +1830,12 @@ void
> > display_channel_create_surface(DisplayChannel *display, uint32_t
> > surface_id
> > uint32_t renderer = g_array_index(renderers,
> > uint32_t,
> > i);
> > surface->context.canvas =
> > create_canvas_for_surface(display, surface, renderer);
> > if (surface->context.canvas) {
> > - display->renderer = renderer;
> > + display->priv->renderer = renderer;
> > break;
> > }
> > }
> > } else {
> > - surface->context.canvas =
> > create_canvas_for_surface(display,
> > surface, display->renderer);
> > + surface->context.canvas =
> > create_canvas_for_surface(display,
> > surface, display->priv->renderer);
> > }
> >
> > spice_return_if_fail(surface->context.canvas);
> > @@ -1859,8 +1859,8 @@ static void on_disconnect(RedChannelClient
> > *rcc)
> >
> > // this was the last channel client
> > spice_debug("#draw=%d, #glz_draw=%d",
> > - display->drawable_count,
> > - display->encoder_shared_data.glz_drawable_count);
> > + display->priv->drawable_count,
> > + display->priv-
> > > encoder_shared_data.glz_drawable_count);
> >
> > }
> >
> > static int handle_migrate_flush_mark(RedChannelClient *rcc)
> > @@ -1887,11 +1887,12 @@ static int
> > handle_migrate_data(RedChannelClient *rcc, uint32_t size, void
> > *messa
> >
> > static SpiceCanvas *image_surfaces_get(SpiceImageSurfaces
> > *surfaces,
> > uint32_t surface_id)
> > {
> > - DisplayChannel *display = SPICE_CONTAINEROF(surfaces,
> > DisplayChannel, image_surfaces);
> > + DisplayChannelPrivate *p = SPICE_CONTAINEROF(surfaces,
> > DisplayChannelPrivate, image_surfaces);
> > + DisplayChannel *display = p->pub;
> >
> > spice_return_val_if_fail(display_channel_validate_surface(dis
> > pla
> > y, surface_id), NULL);
> >
> > - return display->surfaces[surface_id].context.canvas;
> > + return display->priv->surfaces[surface_id].context.canvas;
> > }
> >
> > DisplayChannel* display_channel_new(SpiceServer *reds, RedWorker
> > *worker,
> > @@ -1919,31 +1920,32 @@ DisplayChannel*
> > display_channel_new(SpiceServer *reds, RedWorker *worker,
> > SPICE_MIGRATE_NEED_FLUSH |
> > SPICE_MIGRATE_NEED_DATA_TRANSFER,
> > &cbs, dcc_handle_message);
> > spice_return_val_if_fail(display, NULL);
> > + display->priv->pub = display;
> >
> > clockid_t stat_clock = CLOCK_THREAD_CPUTIME_ID;
> > - stat_init(&display->add_stat, "add", stat_clock);
> > - stat_init(&display->exclude_stat, "exclude", stat_clock);
> > - stat_init(&display->__exclude_stat, "__exclude", stat_clock);
> > + stat_init(&display->priv->add_stat, "add", stat_clock);
> > + stat_init(&display->priv->exclude_stat, "exclude",
> > stat_clock);
> > + stat_init(&display->priv->__exclude_stat, "__exclude",
> > stat_clock);
> > #ifdef RED_STATISTICS
> > RedChannel *channel = RED_CHANNEL(display);
> > - display->cache_hits_counter = stat_add_counter(reds, channel-
> > > stat,
> >
> > - "cache_hits",
> > TRUE);
> > - display->add_to_cache_counter = stat_add_counter(reds,
> > channel-
> > > stat,
> >
> > - "add_to_cach
> > e",
> > TRUE);
> > - display->non_cache_counter = stat_add_counter(reds, channel-
> > > stat,
> >
> > - "non_cache",
> > TRUE);
> > + display->priv->cache_hits_counter = stat_add_counter(reds,
> > channel->stat,
> > + "cache_h
> > its
> > ", TRUE);
> > + display->priv->add_to_cache_counter = stat_add_counter(reds,
> > channel->stat,
> > + "add_t
> > o_c
> > ache", TRUE);
> > + display->priv->non_cache_counter = stat_add_counter(reds,
> > channel->stat,
> > + "non_cach
> > e",
> > TRUE);
> > #endif
> > - image_encoder_shared_init(&display->encoder_shared_data);
> > + image_encoder_shared_init(&display->priv-
> > >encoder_shared_data);
> >
> > - display->n_surfaces = n_surfaces;
> > - display->renderer = RED_RENDERER_INVALID;
> > + display->priv->n_surfaces = n_surfaces;
> > + display->priv->renderer = RED_RENDERER_INVALID;
> >
> > - ring_init(&display->current_list);
> > - display->image_surfaces.ops = &image_surfaces_ops;
> > + ring_init(&display->priv->current_list);
> > + display->priv->image_surfaces.ops = &image_surfaces_ops;
> > drawables_init(display);
> > - image_cache_init(&display->image_cache);
> > - display->stream_video = stream_video;
> > - display->video_codecs = g_array_ref(video_codecs);
> > + image_cache_init(&display->priv->image_cache);
> > + display->priv->stream_video = stream_video;
> > + display->priv->video_codecs = g_array_ref(video_codecs);
> > display_channel_init_streams(display);
> >
> > return display;
> > @@ -1957,11 +1959,11 @@ void
> > display_channel_process_surface_cmd(DisplayChannel *display,
> > RedSurfaceCmd
> > uint8_t *data;
> >
> > surface_id = surface->surface_id;
> > - if SPICE_UNLIKELY(surface_id >= display->n_surfaces) {
> > + if SPICE_UNLIKELY(surface_id >= display->priv->n_surfaces) {
> > return;
> > }
> >
> > - red_surface = &display->surfaces[surface_id];
> > + red_surface = &display->priv->surfaces[surface_id];
> >
> > switch (surface->type) {
> > case QXL_SURFACE_CMD_CREATE: {
> > @@ -2001,18 +2003,18 @@ void
> > display_channel_process_surface_cmd(DisplayChannel *display,
> > RedSurfaceCmd
> > void display_channel_update_compression(DisplayChannel *display,
> > DisplayChannelClient *dcc)
> > {
> > if (dcc_get_jpeg_state(dcc) == SPICE_WAN_COMPRESSION_AUTO) {
> > - display->enable_jpeg = dcc_is_low_bandwidth(dcc);
> > + display->priv->enable_jpeg = dcc_is_low_bandwidth(dcc);
> > } else {
> > - display->enable_jpeg = (dcc_get_jpeg_state(dcc) ==
> > SPICE_WAN_COMPRESSION_ALWAYS);
> > + display->priv->enable_jpeg = (dcc_get_jpeg_state(dcc) ==
> > SPICE_WAN_COMPRESSION_ALWAYS);
> > }
> >
> > if (dcc_get_zlib_glz_state(dcc) ==
> > SPICE_WAN_COMPRESSION_AUTO) {
> > - display->enable_zlib_glz_wrap =
> > dcc_is_low_bandwidth(dcc);
> > + display->priv->enable_zlib_glz_wrap =
> > dcc_is_low_bandwidth(dcc);
> > } else {
> > - display->enable_zlib_glz_wrap =
> > (dcc_get_zlib_glz_state(dcc)
> > == SPICE_WAN_COMPRESSION_ALWAYS);
> > + display->priv->enable_zlib_glz_wrap =
> > (dcc_get_zlib_glz_state(dcc) == SPICE_WAN_COMPRESSION_ALWAYS);
> > }
> > - spice_info("jpeg %s", display->enable_jpeg ? "enabled" :
> > "disabled");
> > - spice_info("zlib-over-glz %s", display->enable_zlib_glz_wrap
> > ?
> > "enabled" : "disabled");
> > + spice_info("jpeg %s", display->priv->enable_jpeg ? "enabled"
> > :
> > "disabled");
> > + spice_info("zlib-over-glz %s", display->priv-
> > > enable_zlib_glz_wrap ? "enabled" : "disabled");
> >
> > }
> >
> > void display_channel_gl_scanout(DisplayChannel *display)
> > @@ -2024,7 +2026,7 @@ static void
> > set_gl_draw_async_count(DisplayChannel *display, int num)
> > {
> > QXLInstance *qxl = display->common.qxl;
> >
> > - display->gl_draw_async_count = num;
> > + display->priv->gl_draw_async_count = num;
> >
> > if (num == 0) {
> > red_qxl_gl_draw_async_complete(qxl);
> > @@ -2035,7 +2037,7 @@ void display_channel_gl_draw(DisplayChannel
> > *display, SpiceMsgDisplayGlDraw *dra
> > {
> > int num;
> >
> > - spice_return_if_fail(display->gl_draw_async_count == 0);
> > + spice_return_if_fail(display->priv->gl_draw_async_count ==
> > 0);
> >
> > num = red_channel_pipes_new_add_push(RED_CHANNEL(display),
> > dcc_gl_draw_item_new, draw);
> > set_gl_draw_async_count(display, num);
> > @@ -2043,23 +2045,23 @@ void
> > display_channel_gl_draw(DisplayChannel
> > *display, SpiceMsgDisplayGlDraw *dra
> >
> > void display_channel_gl_draw_done(DisplayChannel *display)
> > {
> > - set_gl_draw_async_count(display, display->gl_draw_async_count
> > -
> > 1);
> > + set_gl_draw_async_count(display, display->priv-
> > > gl_draw_async_count - 1);
> >
> > }
> >
> > int display_channel_get_stream_id(DisplayChannel *display, Stream
> > *stream)
> > {
> > - return (int)(stream - display->streams_buf);
> > + return (int)(stream - display->priv->streams_buf);
> > }
> >
> > gboolean display_channel_validate_surface(DisplayChannel
> > *display,
> > uint32_t surface_id)
> > {
> > - if SPICE_UNLIKELY(surface_id >= display->n_surfaces) {
> > + if SPICE_UNLIKELY(surface_id >= display->priv->n_surfaces) {
> > spice_warning("invalid surface_id %u", surface_id);
> > return 0;
> > }
> > - if (!display->surfaces[surface_id].context.canvas) {
> > + if (!display->priv->surfaces[surface_id].context.canvas) {
> > spice_warning("canvas address is %p for %d (and is
> > NULL)\n",
> > - &(display-
> > >surfaces[surface_id].context.canvas),
> > surface_id);
> > + &(display->priv-
> > > surfaces[surface_id].context.canvas), surface_id);
> >
> > spice_warning("failed on %d", surface_id);
> > return 0;
> > }
> > @@ -2071,29 +2073,29 @@ void
> > display_channel_update_monitors_config(DisplayChannel *display,
> > uint16_t count,
> > uint16_t
> > max_allowed)
> > {
> >
> > - if (display->monitors_config)
> > - monitors_config_unref(display->monitors_config);
> > + if (display->priv->monitors_config)
> > + monitors_config_unref(display->priv->monitors_config);
> >
> > - display->monitors_config =
> > + display->priv->monitors_config =
> > monitors_config_new(config->heads, count, max_allowed);
> > }
> >
> > void set_monitors_config_to_primary(DisplayChannel *display)
> > {
> > - DrawContext *context = &display->surfaces[0].context;
> > + DrawContext *context = &display->priv->surfaces[0].context;
> > QXLHead head = { 0, };
> >
> > - spice_return_if_fail(display->surfaces[0].context.canvas);
> > + spice_return_if_fail(display->priv-
> > >surfaces[0].context.canvas);
> >
> > - if (display->monitors_config)
> > - monitors_config_unref(display->monitors_config);
> > + if (display->priv->monitors_config)
> > + monitors_config_unref(display->priv->monitors_config);
> >
> > head.width = context->width;
> > head.height = context->height;
> > - display->monitors_config = monitors_config_new(&head, 1, 1);
> > + display->priv->monitors_config = monitors_config_new(&head,
> > 1,
> > 1);
> > }
> >
> > void display_channel_reset_image_cache(DisplayChannel *self)
> > {
> > - image_cache_reset(&self->image_cache);
> > + image_cache_reset(&self->priv->image_cache);
> > }
> > diff --git a/server/display-channel.h b/server/display-channel.h
> > index 022cd93..ce5d419 100644
> > --- a/server/display-channel.h
> > +++ b/server/display-channel.h
> > @@ -157,8 +157,12 @@ struct _Drawable {
> > } u;
> > };
> >
> > -struct DisplayChannel {
> > - CommonGraphicsChannel common; // Must be the first thing
> > +typedef struct DisplayChannelPrivate DisplayChannelPrivate;
> > +/* FIXME: move to separate file */
> > +struct DisplayChannelPrivate
> > +{
> > + DisplayChannel *pub;
> > +
> > uint32_t bits_unique;
> >
> > MonitorsConfig *monitors_config;
> > @@ -208,6 +212,11 @@ struct DisplayChannel {
> > ImageEncoderSharedData encoder_shared_data;
> > };
> >
> > +struct DisplayChannel {
> > + CommonGraphicsChannel common; // Must be the first thing
> > +
> > + DisplayChannelPrivate priv[1];
> > +};
> >
> > #define FOREACH_DCC(channel, _link, _next,
> > _data) \
> > for (_link = (channel ? RED_CHANNEL(channel)->clients :
> > NULL), \
> > diff --git a/server/red-worker.c b/server/red-worker.c
> > index 6df6420..92ab59c 100644
> > --- a/server/red-worker.c
> > +++ b/server/red-worker.c
> > @@ -676,7 +676,9 @@ static void destroy_primary_surface(RedWorker
> > *worker, uint32_t surface_id)
> > display_channel_destroy_surface_wait(display, 0);
> > display_channel_surface_unref(display, 0);
> >
> > + /* FIXME: accessing private data only for warning purposes...
> > spice_warn_if_fail(ring_is_empty(&display->streams));
> > + */
> > spice_warn_if_fail(!display_channel_surface_has_canvas(displa
> > y,
> > surface_id));
> >
> > cursor_channel_reset(worker->cursor_channel);
> > @@ -771,11 +773,13 @@ static void handle_dev_oom(void *opaque,
> > void
> > *payload)
> >
> > spice_return_if_fail(worker->running);
> > // streams? but without streams also leak
> > +#if FIXME
> > spice_debug("OOM1 #draw=%u, #glz_draw=%u current %u pipes
> > %u",
> > display->drawable_count,
> > display->encoder_shared_data.glz_drawable_count,
> > display->current_size,
> > red_channel_sum_pipes_size(display_red_channel));
> > +#endif
> > while (red_process_display(worker, &ring_is_empty)) {
> > red_channel_push(display_red_channel);
> > }
> > @@ -783,11 +787,13 @@ static void handle_dev_oom(void *opaque,
> > void
> > *payload)
> > display_channel_free_some(worker->display_channel);
> > red_qxl_flush_resources(worker->qxl);
> > }
> > +#if FIXME
> > spice_debug("OOM2 #draw=%u, #glz_draw=%u current %u pipes
> > %u",
> > display->drawable_count,
> > display->encoder_shared_data.glz_drawable_count,
> > display->current_size,
> > red_channel_sum_pipes_size(display_red_channel));
> > +#endif
I am ok to remove these debugs, do you have an idea how to fix them
red_qxl_clear_pending(worker->qxl->st,
> > RED_DISPATCHER_PENDING_OOM);
> > }
> >
> > diff --git a/server/stream.c b/server/stream.c
> > index 8997c10..c3877c7 100644
> > --- a/server/stream.c
> > +++ b/server/stream.c
> > @@ -20,12 +20,13 @@
> >
> > #include "stream.h"
> > #include "display-channel.h"
> > +#include "main-channel-client.h"
> >
> > #define FPS_TEST_INTERVAL 1
> > #define FOREACH_STREAMS(display, item) \
> > - for (item = ring_get_head(&(display)->streams); \
> > + for (item = ring_get_head(&(display)->priv->streams); \
> > item != NULL; \
> > - item = ring_next(&(display)->streams, item))
> > + item = ring_next(&(display)->priv->streams, item))
> >
> > static void stream_agent_stats_print(StreamAgent *agent)
> > {
> > @@ -121,25 +122,25 @@ void stream_stop(DisplayChannel *display,
> > Stream *stream)
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
> > stream_destroy_item_new(stream_agent));
> > stream_agent_stats_print(stream_agent);
> > }
> > - display->streams_size_total -= stream->width * stream-
> > >height;
> > + display->priv->streams_size_total -= stream->width * stream-
> > > height;
> >
> > ring_remove(&stream->link);
> > stream_unref(display, stream);
> > }
> >
> > static void stream_free(DisplayChannel *display, Stream *stream)
> > {
> > - stream->next = display->free_streams;
> > - display->free_streams = stream;
> > + stream->next = display->priv->free_streams;
> > + display->priv->free_streams = stream;
> > }
> >
> > void display_channel_init_streams(DisplayChannel *display)
> > {
> > int i;
> >
> > - ring_init(&display->streams);
> > - display->free_streams = NULL;
> > + ring_init(&display->priv->streams);
> > + display->priv->free_streams = NULL;
> > for (i = 0; i < NUM_STREAMS; i++) {
> > - Stream *stream = &display->streams_buf[i];
> > + Stream *stream = &display->priv->streams_buf[i];
> > ring_item_init(&stream->link);
> > stream_free(display, stream);
> > }
> > @@ -153,7 +154,7 @@ void stream_unref(DisplayChannel *display,
> > Stream
> > *stream)
> > spice_warn_if_fail(!ring_item_is_linked(&stream->link));
> >
> > stream_free(display, stream);
> > - display->stream_count--;
> > + display->priv->stream_count--;
> > }
> >
> > void stream_agent_unref(DisplayChannel *display, StreamAgent
> > *agent)
> > @@ -197,7 +198,7 @@ static void
> > update_copy_graduality(DisplayChannel
> > *display, Drawable *drawable)
> > SpiceBitmap *bitmap;
> > spice_return_if_fail(drawable->red_drawable->type ==
> > QXL_DRAW_COPY);
> >
> > - if (display->stream_video != SPICE_STREAM_VIDEO_FILTER) {
> > + if (display->priv->stream_video != SPICE_STREAM_VIDEO_FILTER)
> > {
> > drawable->copy_bitmap_graduality =
> > BITMAP_GRADUAL_INVALID;
> > return;
> > }
> > @@ -406,11 +407,11 @@ static void
> > before_reattach_stream(DisplayChannel *display,
> > static Stream *display_channel_stream_try_new(DisplayChannel
> > *display)
> > {
> > Stream *stream;
> > - if (!display->free_streams) {
> > + if (!display->priv->free_streams) {
> > return NULL;
> > }
> > - stream = display->free_streams;
> > - display->free_streams = display->free_streams->next;
> > + stream = display->priv->free_streams;
> > + display->priv->free_streams = display->priv->free_streams-
> > >next;
> > return stream;
> > }
> >
> > @@ -430,7 +431,7 @@ static void
> > display_channel_create_stream(DisplayChannel *display, Drawable
> > *dra
> > spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
> > src_rect = &drawable->red_drawable->u.copy.src_area;
> >
> > - ring_add(&display->streams, &stream->link);
> > + ring_add(&display->priv->streams, &stream->link);
> > stream->current = drawable;
> > stream->last_time = drawable->creation_time;
> > stream->width = src_rect->right - src_rect->left;
> > @@ -452,13 +453,13 @@ static void
> > display_channel_create_stream(DisplayChannel *display, Drawable
> > *dra
> > }
> > stream->num_input_frames = 0;
> > stream->input_fps_start_time = drawable->creation_time;
> > - display->streams_size_total += stream->width * stream-
> > >height;
> > - display->stream_count++;
> > + display->priv->streams_size_total += stream->width * stream-
> > > height;
> >
> > + display->priv->stream_count++;
> > FOREACH_CLIENT(display, link, next, dcc) {
> > dcc_create_stream(dcc, stream);
> > }
> > spice_debug("stream %d %dx%d (%d, %d) (%d, %d) %u fps",
> > - (int)(stream - display->streams_buf), stream-
> > >width,
> > + (int)(stream - display->priv->streams_buf),
> > stream-
> > > width,
> >
> > stream->height, stream->dest_area.left, stream-
> > > dest_area.top,
> >
> > stream->dest_area.right, stream-
> > >dest_area.bottom,
> > stream->input_fps);
> > @@ -530,7 +531,7 @@ void stream_trace_update(DisplayChannel
> > *display,
> > Drawable *drawable)
> > }
> > }
> >
> > - trace = display->items_trace;
> > + trace = display->priv->items_trace;
> > trace_end = trace + NUM_TRACE_ITEMS;
> > for (; trace < trace_end; trace++) {
> > if (is_next_stream_frame(display, drawable, trace->width,
> > trace->height,
> > @@ -597,7 +598,7 @@ static void
> > dcc_update_streams_max_latency(DisplayChannelClient *dcc,
> > StreamAgen
> > }
> >
> > dcc_set_max_stream_latency(dcc, 0);
> > - if (DCC_TO_DC(dcc)->stream_count == 1) {
> > + if (DCC_TO_DC(dcc)->priv->stream_count == 1) {
> > return;
> > }
> > for (i = 0; i < NUM_STREAMS; i++) {
> > @@ -656,7 +657,7 @@ static uint64_t
> > get_initial_bit_rate(DisplayChannelClient *dcc, Stream *stream)
> > /* dividing the available bandwidth among the active streams,
> > and saving
> > * (1-RED_STREAM_CHANNEL_CAPACITY) of it for other messages
> > */
> > return (RED_STREAM_CHANNEL_CAPACITY * bit_rate *
> > - stream->width * stream->height) / DCC_TO_DC(dcc)-
> > > streams_size_total;
> >
> > + stream->width * stream->height) / DCC_TO_DC(dcc)-
> > >priv-
> > > streams_size_total;
> >
> > }
> >
> > static uint32_t get_roundtrip_ms(void *opaque)
> > @@ -729,8 +730,8 @@ static VideoEncoder*
> > dcc_create_video_encoder(DisplayChannelClient *dcc,
> > int client_has_multi_codec =
> > red_channel_client_test_remote_cap(rcc,
> > SPICE_DISPLAY_CAP_MULTI_CODEC);
> > int i;
> >
> > - for (i = 0; i < display->video_codecs->len; i++) {
> > - RedVideoCodec* video_codec = &g_array_index (display-
> > > video_codecs, RedVideoCodec, i);
> >
> > + for (i = 0; i < display->priv->video_codecs->len; i++) {
> > + RedVideoCodec* video_codec = &g_array_index (display-
> > >priv-
> > > video_codecs, RedVideoCodec, i);
> >
> >
> > if (!client_has_multi_codec &&
> > video_codec->type != SPICE_VIDEO_CODEC_TYPE_MJPEG) {
> > @@ -924,7 +925,7 @@ static void
> > detach_stream_gracefully(DisplayChannel *display, Stream *stream,
> > */
> > void stream_detach_behind(DisplayChannel *display, QRegion
> > *region,
> > Drawable *drawable)
> > {
> > - Ring *ring = &display->streams;
> > + Ring *ring = &display->priv->streams;
> > RingItem *item = ring_get_head(ring);
> > GList *link, *next;
> > DisplayChannelClient *dcc;
> > @@ -960,7 +961,7 @@ void stream_detach_and_stop(DisplayChannel
> > *display)
> > RingItem *stream_item;
> >
> > spice_debug(NULL);
> > - while ((stream_item = ring_get_head(&display->streams))) {
> > + while ((stream_item = ring_get_head(&display->priv-
> > >streams))) {
> > Stream *stream = SPICE_CONTAINEROF(stream_item, Stream,
> > link);
> >
> > detach_stream_gracefully(display, stream, NULL);
> > @@ -970,7 +971,7 @@ void stream_detach_and_stop(DisplayChannel
> > *display)
> >
> > void stream_timeout(DisplayChannel *display)
> > {
> > - Ring *ring = &display->streams;
> > + Ring *ring = &display->priv->streams;
> > RingItem *item;
> >
> > red_time_t now = spice_get_monotonic_time_ns();
> > @@ -993,7 +994,7 @@ void stream_trace_add_drawable(DisplayChannel
> > *display, Drawable *item)
> > return;
> > }
> >
> > - trace = &display->items_trace[display->next_item_trace++ &
> > ITEMS_TRACE_MASK];
> > + trace = &display->priv->items_trace[display->priv-
> > > next_item_trace++ & ITEMS_TRACE_MASK];
> >
> > trace->time = item->creation_time;
> > trace->first_frame_time = item->first_frame_time;
> > trace->frames_count = item->frames_count;
>
>
Acked-by: Pavel Grunt <pgrunt@xxxxxxxxxx>
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel