[Spice-devel] [PATCH] worker: move stream to display channel
Frediano Ziglio
fziglio at redhat.com
Tue Nov 10 09:42:57 PST 2015
> Thanks, it maintains the existing behavior now. ACK.
>
Merged
Frediano
>
> On Tue, 2015-11-10 at 17:11 +0000, Frediano Ziglio wrote:
> > From: Marc-André Lureau <marcandre.lureau at gmail.com>
> >
> > ---
> > server/display-channel.c | 44 ++++
> > server/display-channel.h | 22 +-
> > server/red_worker.c | 563 +++++++++++++++++++++----------------
> > ----------
> > server/stream.c | 4 +-
> > server/stream.h | 10 +
> > 5 files changed, 323 insertions(+), 320 deletions(-)
> >
> > diff --git a/server/display-channel.c b/server/display-channel.c
> > index 6aefe09..8775496 100644
> > --- a/server/display-channel.c
> > +++ b/server/display-channel.c
> > @@ -225,3 +225,47 @@ void
> > dcc_push_monitors_config(DisplayChannelClient *dcc)
> > red_monitors_config_item_add(dcc);
> > red_channel_client_push(&dcc->common.base);
> > }
> > +
> > +int display_channel_get_streams_timeout(DisplayChannel *display)
> > +{
> > + int timeout = INT_MAX;
> > + Ring *ring = &display->streams;
> > + RingItem *item = ring;
> > +
> > + red_time_t now = red_get_monotonic_time();
> > + while ((item = ring_next(ring, item))) {
> > + Stream *stream;
> > +
> > + stream = SPICE_CONTAINEROF(item, Stream, link);
> > + red_time_t delta = (stream->last_time + RED_STREAM_TIMEOUT)
> > - now;
> > +
> > + if (delta < 1000 * 1000) {
> > + return 0;
> > + }
> > + timeout = MIN(timeout, (unsigned int)(delta / (1000 *
> > 1000)));
> > + }
> > + return timeout;
> > +}
> > +
> > +void display_channel_set_stream_video(DisplayChannel *display, int
> > stream_video)
> > +{
> > + spice_return_if_fail(display);
> > + spice_return_if_fail(stream_video !=
> > SPICE_STREAM_VIDEO_INVALID);
> > +
> > + switch (stream_video) {
> > + case SPICE_STREAM_VIDEO_ALL:
> > + spice_info("sv all");
> > + break;
> > + case SPICE_STREAM_VIDEO_FILTER:
> > + spice_info("sv filter");
> > + break;
> > + case SPICE_STREAM_VIDEO_OFF:
> > + spice_info("sv off");
> > + break;
> > + default:
> > + spice_warn_if_reached();
> > + return;
> > + }
> > +
> > + display->stream_video = stream_video;
> > +}
> > diff --git a/server/display-channel.h b/server/display-channel.h
> > index 7173c6e..24fb354 100644
> > --- a/server/display-channel.h
> > +++ b/server/display-channel.h
> > @@ -57,9 +57,6 @@
> > #include "stream.h"
> >
> > typedef struct DisplayChannel DisplayChannel;
> > -typedef struct DisplayChannelClient DisplayChannelClient;
> > -
> > -typedef struct Drawable Drawable;
> >
> > #define PALETTE_CACHE_HASH_SHIFT 8
> > #define PALETTE_CACHE_HASH_SIZE (1 << PALETTE_CACHE_HASH_SHIFT)
> > @@ -270,6 +267,10 @@ MonitorsConfig* monitors_config_new
> > (QXLHead *h
> > MonitorsConfig * monitors_config_ref
> > (MonitorsConfig *config);
> > void monitors_config_unref
> > (MonitorsConfig *config);
> >
> > +#define TRACE_ITEMS_SHIFT 3
> > +#define NUM_TRACE_ITEMS (1 << TRACE_ITEMS_SHIFT)
> > +#define ITEMS_TRACE_MASK (NUM_TRACE_ITEMS - 1)
> > +
> > struct DisplayChannel {
> > CommonChannel common; // Must be the first thing
> >
> > @@ -286,6 +287,15 @@ struct DisplayChannel {
> >
> > RedCompressBuf *free_compress_bufs;
> >
> > + int stream_video;
> > + uint32_t stream_count;
> > + Stream streams_buf[NUM_STREAMS];
> > + Stream *free_streams;
> > + Ring streams;
> > + ItemTrace items_trace[NUM_TRACE_ITEMS];
> > + uint32_t next_item_trace;
> > + uint64_t streams_size_total;
> > +
> > ImageCache image_cache;
> >
> > #ifdef RED_STATISTICS
> > @@ -304,6 +314,12 @@ struct DisplayChannel {
> > #endif
> > };
> >
> > +void display_channel_set_stream_video
> > (DisplayChannel *display,
> > +
> > int stream_video);
> > +void display_channel_attach_stream
> > (DisplayChannel *display,
> > +
> > Drawable *drawable,
> > +
> > Stream *stream);
> > +int display_channel_get_streams_timeout
> > (DisplayChannel *display);
> > void display_channel_compress_stats_print
> > (const DisplayChannel *display);
> > void display_channel_compress_stats_reset
> > (DisplayChannel *display);
> >
> > diff --git a/server/red_worker.c b/server/red_worker.c
> > index 6b61a10..7e75554 100644
> > --- a/server/red_worker.c
> > +++ b/server/red_worker.c
> > @@ -349,20 +349,6 @@ typedef struct RedSurface {
> > QXLReleaseInfoExt create, destroy;
> > } RedSurface;
> >
> > -typedef struct ItemTrace {
> > - red_time_t time;
> > - int frames_count;
> > - int gradual_frames_count;
> > - int last_gradual_frame;
> > - int width;
> > - int height;
> > - SpiceRect dest_area;
> > -} ItemTrace;
> > -
> > -#define TRACE_ITEMS_SHIFT 3
> > -#define NUM_TRACE_ITEMS (1 << TRACE_ITEMS_SHIFT)
> > -#define ITEMS_TRACE_MASK (NUM_TRACE_ITEMS - 1)
> > -
> > #define NUM_DRAWABLES 1000
> >
> > typedef struct RedWorker {
> > @@ -390,9 +376,6 @@ typedef struct RedWorker {
> > uint32_t drawable_count;
> > uint32_t red_drawable_count;
> > uint32_t glz_drawable_count;
> > -
> > - uint32_t stream_count;
> > -
> > uint32_t bits_unique;
> >
> > _Drawable drawables[NUM_DRAWABLES];
> > @@ -404,14 +387,6 @@ typedef struct RedWorker {
> > spice_wan_compression_t jpeg_state;
> > spice_wan_compression_t zlib_glz_state;
> >
> > - uint32_t streaming_video;
> > - Stream streams_buf[NUM_STREAMS];
> > - Stream *free_streams;
> > - Ring streams;
> > - ItemTrace items_trace[NUM_TRACE_ITEMS];
> > - uint32_t next_item_trace;
> > - uint64_t streams_size_total;
> > -
> > QuicData quic_data;
> > QuicContext *quic;
> >
> > @@ -480,16 +455,13 @@ static void red_update_area(RedWorker *worker,
> > const SpiceRect *area, int surfac
> > static void red_update_area_till(RedWorker *worker, const SpiceRect
> > *area, int surface_id,
> > Drawable *last);
> > static void red_worker_drawable_unref(RedWorker *worker, Drawable
> > *drawable);
> > -static void red_display_release_stream(RedWorker *worker,
> > StreamAgent *agent);
> > -static inline void red_detach_stream(RedWorker *worker, Stream
> > *stream, int detach_sized);
> > -static void red_stop_stream(RedWorker *worker, Stream *stream);
> > -static inline void red_stream_maintenance(RedWorker *worker,
> > Drawable *candidate, Drawable *sect);
> > +static void detach_stream(DisplayChannel *display, Stream *stream,
> > int detach_sized);
> > +static inline void display_channel_stream_maintenance(DisplayChannel
> > *display, Drawable *candidate, Drawable *sect);
> > static inline void display_begin_send_message(RedChannelClient
> > *rcc);
> > static void red_release_glz(DisplayChannelClient *dcc);
> > static void red_freeze_glz(DisplayChannelClient *dcc);
> > static void display_channel_push_release(DisplayChannelClient *dcc,
> > uint8_t type, uint64_t id,
> > uint64_t* sync_data);
> > -static void red_display_release_stream_clip(RedWorker *worker,
> > StreamClipItem *item);
> > static int
> > red_display_free_some_independent_glz_drawables(DisplayChannelClient
> > *dcc);
> > static void red_display_free_glz_drawable(DisplayChannelClient *dcc,
> > RedGlzDrawable *drawable);
> > static ImageItem *red_add_surface_area_image(DisplayChannelClient
> > *dcc, int surface_id,
> > @@ -526,39 +498,40 @@ static void
> > display_channel_client_release_item_after_push(DisplayChannelClient
> > SAFE_FOREACH(link, next, drawable, &(drawable)->glz_ring, glz,
> > LINK_TO_GLZ(link))
> >
> >
> > -static inline int get_stream_id(RedWorker *worker, Stream *stream)
> > +static int get_stream_id(DisplayChannel *display, Stream *stream)
> > {
> > - return (int)(stream - worker->streams_buf);
> > + return (int)(stream - display->streams_buf);
> > }
> >
> > -static inline void red_free_stream(RedWorker *worker, Stream
> > *stream)
> > +static void display_stream_free(DisplayChannel *display, Stream
> > *stream)
> > {
> > - stream->next = worker->free_streams;
> > - worker->free_streams = stream;
> > + stream->next = display->free_streams;
> > + display->free_streams = stream;
> > }
> >
> > -static void red_release_stream(RedWorker *worker, Stream *stream)
> > +static void display_stream_unref(DisplayChannel *display, Stream
> > *stream)
> > {
> > - if (!--stream->refs) {
> > - spice_assert(!ring_item_is_linked(&stream->link));
> > - red_free_stream(worker, stream);
> > - worker->stream_count--;
> > - }
> > + if (--stream->refs != 0)
> > + return;
> > +
> > + spice_warn_if_fail(!ring_item_is_linked(&stream->link));
> > + display_stream_free(display, stream);
> > + display->stream_count--;
> > }
> >
> > -static void red_display_release_stream(RedWorker *worker,
> > StreamAgent *agent)
> > +static void display_stream_agent_unref(DisplayChannel *display,
> > StreamAgent *agent)
> > {
> > - spice_assert(agent->stream);
> > - red_release_stream(worker, agent->stream);
> > + display_stream_unref(display, agent->stream);
> > }
> >
> > -static void red_display_release_stream_clip(RedWorker *worker,
> > StreamClipItem *item)
> > +static void display_stream_clip_unref(DisplayChannel *display,
> > StreamClipItem *item)
> > {
> > - if (!--item->refs) {
> > - red_display_release_stream(worker, item->stream_agent);
> > - free(item->rects);
> > - free(item);
> > - }
> > + if (--item->refs != 0)
> > + return;
> > +
> > + display_stream_agent_unref(display, item->stream_agent);
> > + free(item->rects);
> > + free(item);
> > }
> >
> > static void dcc_push_stream_agent_clip(DisplayChannelClient* dcc,
> > StreamAgent *agent)
> > @@ -566,21 +539,18 @@ static void
> > dcc_push_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *a
> > StreamClipItem *item = stream_clip_item_new(dcc, agent);
> > int n_rects;
> >
> > - if (!item) {
> > - spice_critical("alloc failed");
> > - }
> > item->clip_type = SPICE_CLIP_TYPE_RECTS;
> >
> > n_rects = pixman_region32_n_rects(&agent->clip);
> > -
> > item->rects = spice_malloc_n_m(n_rects, sizeof(SpiceRect),
> > sizeof(SpiceClipRects));
> > item->rects->num_rects = n_rects;
> > region_ret_rects(&agent->clip, item->rects->rects, n_rects);
> > +
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (PipeItem
> > *)item);
> > }
> >
> >
> > -static void red_attach_stream(RedWorker *worker, Drawable *drawable,
> > Stream *stream)
> > +void attach_stream(DisplayChannel *display, Drawable *drawable,
> > Stream *stream)
> > {
> > DisplayChannelClient *dcc;
> > RingItem *item, *next;
> > @@ -602,11 +572,11 @@ static void red_attach_stream(RedWorker
> > *worker, Drawable *drawable, Stream *str
> > stream->num_input_frames++;
> > }
> >
> > - FOREACH_DCC(worker->display_channel, item, next, dcc) {
> > + FOREACH_DCC(display, item, next, dcc) {
> > StreamAgent *agent;
> > QRegion clip_in_draw_dest;
> >
> > - agent = &dcc->stream_agents[get_stream_id(worker, stream)];
> > + agent = &dcc->stream_agents[get_stream_id(display, stream)];
> > region_or(&agent->vis_region, &drawable
> > ->tree_item.base.rgn);
> >
> > region_init(&clip_in_draw_dest);
> > @@ -624,18 +594,18 @@ static void red_attach_stream(RedWorker
> > *worker, Drawable *drawable, Stream *str
> > }
> > }
> >
> > -static void red_stop_stream(RedWorker *worker, Stream *stream)
> > +static void stop_stream(DisplayChannel *display, Stream *stream)
> > {
> > DisplayChannelClient *dcc;
> > RingItem *item, *next;
> >
> > spice_assert(ring_item_is_linked(&stream->link));
> > spice_assert(!stream->current);
> > - spice_debug("stream %d", get_stream_id(worker, stream));
> > - FOREACH_DCC(worker->display_channel, item, next, dcc) {
> > + spice_debug("stream %d", get_stream_id(display, stream));
> > + FOREACH_DCC(display, item, next, dcc) {
> > StreamAgent *stream_agent;
> >
> > - stream_agent = &dcc->stream_agents[get_stream_id(worker,
> > stream)];
> > + stream_agent = &dcc->stream_agents[get_stream_id(display,
> > stream)];
> > region_clear(&stream_agent->vis_region);
> > region_clear(&stream_agent->clip);
> > spice_assert(!pipe_item_is_linked(&stream_agent
> > ->destroy_item));
> > @@ -653,9 +623,9 @@ static void red_stop_stream(RedWorker *worker,
> > Stream *stream)
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
> > &stream_agent->destroy_item);
> > stream_agent_stats_print(stream_agent);
> > }
> > - worker->streams_size_total -= stream->width * stream->height;
> > + display->streams_size_total -= stream->width * stream->height;
> > ring_remove(&stream->link);
> > - red_release_stream(worker, stream);
> > + display_stream_unref(display, stream);
> > }
> >
> > /* fixme: move to display channel */
> > @@ -703,7 +673,7 @@ QXLInstance* red_worker_get_qxl(RedWorker
> > *worker)
> > return worker->qxl;
> > }
> >
> > -static inline int is_primary_surface(RedWorker *worker, uint32_t
> > surface_id)
> > +static inline int is_primary_surface(DisplayChannel *display,
> > uint32_t surface_id)
> > {
> > if (surface_id == 0) {
> > return TRUE;
> > @@ -989,8 +959,6 @@ static void drawables_init(RedWorker *worker)
> > }
> >
> >
> > -static void red_reset_stream_trace(RedWorker *worker);
> > -
> > static SurfaceDestroyItem *get_surface_destroy_item(RedChannel
> > *channel,
> > uint32_t
> > surface_id)
> > {
> > @@ -1022,27 +990,28 @@ static inline void
> > red_destroy_surface_item(RedWorker *worker,
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &destroy
> > ->pipe_item);
> > }
> >
> > -static void red_reset_stream_trace(RedWorker *worker)
> > +static void stop_streams(DisplayChannel *display)
> > {
> > - Ring *ring = &worker->streams;
> > + Ring *ring = &display->streams;
> > RingItem *item = ring_get_head(ring);
> >
> > while (item) {
> > Stream *stream = SPICE_CONTAINEROF(item, Stream, link);
> > item = ring_next(ring, item);
> > if (!stream->current) {
> > - red_stop_stream(worker, stream);
> > + stop_stream(display, stream);
> > } else {
> > spice_info("attached stream");
> > }
> > }
> >
> > - worker->next_item_trace = 0;
> > - memset(worker->items_trace, 0, sizeof(worker->items_trace));
> > + display->next_item_trace = 0;
> > + memset(display->items_trace, 0, sizeof(display->items_trace));
> > }
> >
> > static void red_surface_unref(RedWorker *worker, uint32_t
> > surface_id)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > RedSurface *surface = &worker->surfaces[surface_id];
> > DisplayChannelClient *dcc;
> > RingItem *link, *next;
> > @@ -1052,8 +1021,8 @@ static void red_surface_unref(RedWorker
> > *worker, uint32_t surface_id)
> > }
> >
> > // only primary surface streams are supported
> > - if (is_primary_surface(worker, surface_id)) {
> > - red_reset_stream_trace(worker);
> > + if (is_primary_surface(worker->display_channel, surface_id)) {
> > + stop_streams(display);
> > }
> > spice_assert(surface->context.canvas);
> >
> > @@ -1150,7 +1119,7 @@ static void red_worker_drawable_unref(RedWorker
> > *worker, Drawable *drawable)
> > spice_warn_if_fail(ring_is_empty(&drawable->pipes));
> >
> > if (drawable->stream) {
> > - red_detach_stream(worker, drawable->stream, TRUE);
> > + detach_stream(worker->display_channel, drawable->stream,
> > TRUE);
> > }
> > region_destroy(&drawable->tree_item.base.rgn);
> >
> > @@ -1206,14 +1175,15 @@ static inline void
> > container_cleanup(RedWorker *worker, Container *container)
> > }
> > }
> >
> > -static inline void red_add_item_trace(RedWorker *worker, Drawable
> > *item)
> > +static void display_stream_trace_add_drawable(DisplayChannel
> > *display, Drawable *item)
> > {
> > ItemTrace *trace;
> > - if (!item->streamable) {
> > +
> > + if (item->stream || !item->streamable) {
> > return;
> > }
> >
> > - trace = &worker->items_trace[worker->next_item_trace++ &
> > ITEMS_TRACE_MASK];
> > + trace = &display->items_trace[display->next_item_trace++ &
> > ITEMS_TRACE_MASK];
> > trace->time = item->creation_time;
> > trace->frames_count = item->frames_count;
> > trace->gradual_frames_count = item->gradual_frames_count;
> > @@ -1245,9 +1215,7 @@ static void red_flush_source_surfaces(RedWorker
> > *worker, Drawable *drawable)
> >
> > static inline void current_remove_drawable(RedWorker *worker,
> > Drawable *item)
> > {
> > - if (!item->stream) {
> > - red_add_item_trace(worker, item);
> > - }
> > + display_stream_trace_add_drawable(worker->display_channel,
> > item);
> > remove_shadow(&item->tree_item);
> > ring_remove(&item->tree_item.base.siblings_link);
> > ring_remove(&item->list_link);
> > @@ -1475,7 +1443,7 @@ static inline void __exclude_region(RedWorker
> > *worker, Ring *ring, TreeItem *ite
> > } else {
> > if (frame_candidate) {
> > Drawable *drawable = SPICE_CONTAINEROF(draw,
> > Drawable, tree_item);
> > - red_stream_maintenance(worker, frame_candidate,
> > drawable);
> > + display_channel_stream_maintenance(worker
> > ->display_channel, frame_candidate, drawable);
> > }
> > region_exclude(&draw->base.rgn, &and_rgn);
> > }
> > @@ -1665,7 +1633,8 @@ static int is_same_drawable(RedWorker *worker,
> > Drawable *d1, Drawable *d2)
> > }
> > }
> >
> > -static inline void red_detach_stream(RedWorker *worker, Stream
> > *stream, int detach_sized)
> > +static void detach_stream(DisplayChannel *display, Stream *stream,
> > + int detach_sized)
> > {
> > spice_assert(stream->current && stream->current->stream);
> > spice_assert(stream->current->stream == stream);
> > @@ -1692,13 +1661,14 @@ static int
> > red_display_drawable_is_in_pipe(DisplayChannelClient *dcc, Drawable *
> >
> > /*
> > * after dcc_detach_stream_gracefully is called for all the display
> > channel clients,
> > - * red_detach_stream should be called. See comment (1).
> > + * detach_stream should be called. See comment (1).
> > */
> > -static inline void dcc_detach_stream_gracefully(DisplayChannelClient
> > *dcc,
> > - Stream
> > *stream,
> > - Drawable
> > *update_area_limit)
> > +static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
> > + Stream *stream,
> > + Drawable
> > *update_area_limit)
> > {
> > - int stream_id = get_stream_id(DCC_TO_WORKER(dcc), stream);
> > + DisplayChannel *display = DCC_TO_DC(dcc);
> > + int stream_id = get_stream_id(display, stream);
> > StreamAgent *agent = &dcc->stream_agents[stream_id];
> >
> > /* stopping the client from playing older frames at once*/
> > @@ -1761,17 +1731,17 @@ clear_vis_region:
> > region_clear(&agent->vis_region);
> > }
> >
> > -static inline void red_detach_stream_gracefully(RedWorker *worker,
> > Stream *stream,
> > - Drawable
> > *update_area_limit)
> > +static void detach_stream_gracefully(DisplayChannel *display, Stream
> > *stream,
> > + Drawable *update_area_limit)
> > {
> > RingItem *item, *next;
> > DisplayChannelClient *dcc;
> >
> > - FOREACH_DCC(worker->display_channel, item, next, dcc) {
> > + FOREACH_DCC(display, item, next, dcc) {
> > dcc_detach_stream_gracefully(dcc, stream,
> > update_area_limit);
> > }
> > if (stream->current) {
> > - red_detach_stream(worker, stream, TRUE);
> > + detach_stream(display, stream, TRUE);
> > }
> > }
> >
> > @@ -1785,55 +1755,55 @@ static inline void
> > red_detach_stream_gracefully(RedWorker *worker, Stream *strea
> > * involves sending an upgrade image to the client, this
> > drawable won't be rendered
> > * (see dcc_detach_stream_gracefully).
> > */
> > -static void red_detach_streams_behind(RedWorker *worker, QRegion
> > *region, Drawable *drawable)
> > +static void detach_streams_behind(DisplayChannel *display, QRegion
> > *region, Drawable *drawable)
> > {
> > - Ring *ring = &worker->streams;
> > + Ring *ring = &display->streams;
> > RingItem *item = ring_get_head(ring);
> > RingItem *dcc_ring_item, *next;
> > DisplayChannelClient *dcc;
> > - int has_clients = display_is_connected(worker);
> > + bool is_connected =
> > red_channel_is_connected(RED_CHANNEL(display));
> >
> > while (item) {
> > Stream *stream = SPICE_CONTAINEROF(item, Stream, link);
> > - int detach_stream = 0;
> > + int detach = 0;
> > item = ring_next(ring, item);
> >
> > - FOREACH_DCC(worker->display_channel, dcc_ring_item, next,
> > dcc) {
> > - StreamAgent *agent = &dcc
> > ->stream_agents[get_stream_id(worker, stream)];
> > + FOREACH_DCC(display, dcc_ring_item, next, dcc) {
> > + StreamAgent *agent = &dcc
> > ->stream_agents[get_stream_id(display, stream)];
> >
> > if (region_intersects(&agent->vis_region, region)) {
> > dcc_detach_stream_gracefully(dcc, stream, drawable);
> > - detach_stream = 1;
> > - spice_debug("stream %d", get_stream_id(worker,
> > stream));
> > + detach = 1;
> > + spice_debug("stream %d", get_stream_id(display,
> > stream));
> > }
> > }
> > - if (detach_stream && stream->current) {
> > - red_detach_stream(worker, stream, TRUE);
> > - } else if (!has_clients) {
> > + if (detach && stream->current) {
> > + detach_stream(display, stream, TRUE);
> > + } else if (!is_connected) {
> > if (stream->current &&
> > region_intersects(&stream->current
> > ->tree_item.base.rgn, region)) {
> > - red_detach_stream(worker, stream, TRUE);
> > + detach_stream(display, stream, TRUE);
> > }
> > }
> > }
> > }
> >
> > -static void red_streams_update_visible_region(RedWorker *worker,
> > Drawable *drawable)
> > +static void streams_update_visible_region(DisplayChannel *display,
> > Drawable *drawable)
> > {
> > Ring *ring;
> > RingItem *item;
> > RingItem *dcc_ring_item, *next;
> > DisplayChannelClient *dcc;
> >
> > - if (!display_is_connected(worker)) {
> > + if (!red_channel_is_connected(RED_CHANNEL(display))) {
> > return;
> > }
> >
> > - if (!is_primary_surface(worker, drawable->surface_id)) {
> > + if (!is_primary_surface(display, drawable->surface_id)) {
> > return;
> > }
> >
> > - ring = &worker->streams;
> > + ring = &display->streams;
> > item = ring_get_head(ring);
> >
> > while (item) {
> > @@ -1846,8 +1816,8 @@ static void
> > red_streams_update_visible_region(RedWorker *worker, Drawable *drawa
> > continue;
> > }
> >
> > - FOREACH_DCC(worker->display_channel, dcc_ring_item, next,
> > dcc) {
> > - agent = &dcc->stream_agents[get_stream_id(worker,
> > stream)];
> > + FOREACH_DCC(display, dcc_ring_item, next, dcc) {
> > + agent = &dcc->stream_agents[get_stream_id(display,
> > stream)];
> >
> > if (region_intersects(&agent->vis_region, &drawable
> > ->tree_item.base.rgn)) {
> > region_exclude(&agent->vis_region, &drawable
> > ->tree_item.base.rgn);
> > @@ -1858,30 +1828,9 @@ static void
> > red_streams_update_visible_region(RedWorker *worker, Drawable *drawa
> > }
> > }
> >
> > -static inline unsigned int red_get_streams_timout(RedWorker *worker)
> > +static void display_channel_streams_timeout(DisplayChannel *display)
> > {
> > - unsigned int timout = -1;
> > - Ring *ring = &worker->streams;
> > - RingItem *item = ring;
> > -
> > - red_time_t now = red_get_monotonic_time();
> > - while ((item = ring_next(ring, item))) {
> > - Stream *stream;
> > -
> > - stream = SPICE_CONTAINEROF(item, Stream, link);
> > - red_time_t delta = (stream->last_time + RED_STREAM_TIMEOUT)
> > - now;
> > -
> > - if (delta < 1000 * 1000) {
> > - return 0;
> > - }
> > - timout = MIN(timout, (unsigned int)(delta / (1000 * 1000)));
> > - }
> > - return timout;
> > -}
> > -
> > -static inline void red_handle_streams_timout(RedWorker *worker)
> > -{
> > - Ring *ring = &worker->streams;
> > + Ring *ring = &display->streams;
> > RingItem *item;
> >
> > red_time_t now = red_get_monotonic_time();
> > @@ -1890,20 +1839,20 @@ static inline void
> > red_handle_streams_timout(RedWorker *worker)
> > Stream *stream = SPICE_CONTAINEROF(item, Stream, link);
> > item = ring_next(ring, item);
> > if (now >= (stream->last_time + RED_STREAM_TIMEOUT)) {
> > - red_detach_stream_gracefully(worker, stream, NULL);
> > - red_stop_stream(worker, stream);
> > + detach_stream_gracefully(display, stream, NULL);
> > + stop_stream(display, stream);
> > }
> > }
> > }
> >
> > -static inline Stream *red_alloc_stream(RedWorker *worker)
> > +static Stream *display_channel_stream_try_new(DisplayChannel
> > *display)
> > {
> > Stream *stream;
> > - if (!worker->free_streams) {
> > + if (!display->free_streams) {
> > return NULL;
> > }
> > - stream = worker->free_streams;
> > - worker->free_streams = worker->free_streams->next;
> > + stream = display->free_streams;
> > + display->free_streams = display->free_streams->next;
> > return stream;
> > }
> >
> > @@ -1952,7 +1901,7 @@ static uint64_t
> > red_stream_get_initial_bit_rate(DisplayChannelClient *dcc,
> > /* 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_WORKER(dcc)
> > ->streams_size_total;
> > + stream->width * stream->height) / DCC_TO_DC(dcc)
> > ->streams_size_total;
> > }
> >
> > static uint32_t red_stream_mjpeg_encoder_get_roundtrip(void *opaque)
> > @@ -1994,7 +1943,7 @@ static void
> > red_display_update_streams_max_latency(DisplayChannelClient *dcc, St
> > }
> >
> > dcc->streams_max_latency = 0;
> > - if (DCC_TO_WORKER(dcc)->stream_count == 1) {
> > + if (DCC_TO_DC(dcc)->stream_count == 1) {
> > return;
> > }
> > for (i = 0; i < NUM_STREAMS; i++) {
> > @@ -2035,7 +1984,7 @@ static void
> > red_stream_update_client_playback_latency(void *opaque, uint32_t del
> >
> > static void dcc_create_stream(DisplayChannelClient *dcc, Stream
> > *stream)
> > {
> > - StreamAgent *agent = &dcc
> > ->stream_agents[get_stream_id(DCC_TO_WORKER(dcc), stream)];
> > + StreamAgent *agent = &dcc
> > ->stream_agents[get_stream_id(DCC_TO_DC(dcc), stream)];
> >
> > stream->refs++;
> > spice_assert(region_is_empty(&agent->vis_region));
> > @@ -2071,7 +2020,7 @@ static void
> > dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
> > agent->report_id = rand();
> > red_channel_pipe_item_init(RED_CHANNEL_CLIENT(dcc)->channel,
> > &report_pipe_item->pipe_item,
> >
> > PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
> > - report_pipe_item->stream_id =
> > get_stream_id(DCC_TO_WORKER(dcc), stream);
> > + report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc),
> > stream);
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
> > &report_pipe_item->pipe_item);
> > }
> > #ifdef STREAM_STATS
> > @@ -2082,7 +2031,7 @@ static void
> > dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
> > #endif
> > }
> >
> > -static void red_create_stream(RedWorker *worker, Drawable *drawable)
> > +static void display_channel_create_stream(DisplayChannel *display,
> > Drawable *drawable)
> > {
> > DisplayChannelClient *dcc;
> > RingItem *dcc_ring_item, *next;
> > @@ -2091,14 +2040,14 @@ static void red_create_stream(RedWorker
> > *worker, Drawable *drawable)
> >
> > spice_assert(!drawable->stream);
> >
> > - if (!(stream = red_alloc_stream(worker))) {
> > + if (!(stream = display_channel_stream_try_new(display))) {
> > return;
> > }
> >
> > spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
> > src_rect = &drawable->red_drawable->u.copy.src_area;
> >
> > - ring_add(&worker->streams, &stream->link);
> > + ring_add(&display->streams, &stream->link);
> > stream->current = drawable;
> > stream->last_time = drawable->creation_time;
> > stream->width = src_rect->right - src_rect->left;
> > @@ -2111,12 +2060,13 @@ static void red_create_stream(RedWorker
> > *worker, Drawable *drawable)
> > stream->input_fps = MAX_FPS;
> > stream->num_input_frames = 0;
> > stream->input_fps_start_time = drawable->creation_time;
> > - worker->streams_size_total += stream->width * stream->height;
> > - worker->stream_count++;
> > - FOREACH_DCC(worker->display_channel, dcc_ring_item, next, dcc) {
> > + display->streams_size_total += stream->width * stream->height;
> > + display->stream_count++;
> > + FOREACH_DCC(display, dcc_ring_item, next, dcc) {
> > dcc_create_stream(dcc, stream);
> > }
> > - spice_debug("stream %d %dx%d (%d, %d) (%d, %d)", (int)(stream -
> > worker->streams_buf), stream->width,
> > + spice_debug("stream %d %dx%d (%d, %d) (%d, %d)",
> > + (int)(stream - display->streams_buf), stream->width,
> > stream->height, stream->dest_area.left, stream
> > ->dest_area.top,
> > stream->dest_area.right, stream->dest_area.bottom);
> > return;
> > @@ -2124,7 +2074,7 @@ static void red_create_stream(RedWorker
> > *worker, Drawable *drawable)
> >
> > static void dcc_create_all_streams(DisplayChannelClient *dcc)
> > {
> > - Ring *ring = &DCC_TO_WORKER(dcc)->streams;
> > + Ring *ring = &DCC_TO_DC(dcc)->streams;
> > RingItem *item = ring;
> >
> > while ((item = ring_next(ring, item))) {
> > @@ -2136,12 +2086,12 @@ static void
> > dcc_create_all_streams(DisplayChannelClient *dcc)
> > static void dcc_init_stream_agents(DisplayChannelClient *dcc)
> > {
> > int i;
> > - RedWorker *worker = DCC_TO_WORKER(dcc);
> > + DisplayChannel *display = DCC_TO_DC(dcc);
> > RedChannel *channel = RED_CHANNEL_CLIENT(dcc)->channel;
> >
> > for (i = 0; i < NUM_STREAMS; i++) {
> > StreamAgent *agent = &dcc->stream_agents[i];
> > - agent->stream = &worker->streams_buf[i];
> > + agent->stream = &display->streams_buf[i];
> > region_init(&agent->vis_region);
> > region_init(&agent->clip);
> > red_channel_pipe_item_init(channel, &agent->create_item,
> > PIPE_ITEM_TYPE_STREAM_CREATE);
> > @@ -2166,14 +2116,14 @@ static void
> > dcc_destroy_stream_agents(DisplayChannelClient *dcc)
> > }
> > }
> >
> > -static inline int __red_is_next_stream_frame(RedWorker *worker,
> > - const Drawable
> > *candidate,
> > - const int
> > other_src_width,
> > - const int
> > other_src_height,
> > - const SpiceRect
> > *other_dest,
> > - const red_time_t
> > other_time,
> > - const Stream *stream,
> > - int
> > container_candidate_allowed)
> > +static int is_next_stream_frame(DisplayChannel *display,
> > + const Drawable *candidate,
> > + const int other_src_width,
> > + const int other_src_height,
> > + const SpiceRect *other_dest,
> > + const red_time_t other_time,
> > + const Stream *stream,
> > + int container_candidate_allowed)
> > {
> > RedDrawable *red_drawable;
> > int is_frame_container = FALSE;
> > @@ -2236,22 +2186,8 @@ static inline int
> > __red_is_next_stream_frame(RedWorker *worker,
> > }
> > }
> >
> > -static inline int red_is_next_stream_frame(RedWorker *worker, const
> > Drawable *candidate,
> > - const Drawable *prev)
> > -{
> > - if (!candidate->streamable) {
> > - return FALSE;
> > - }
> > -
> > - SpiceRect* prev_src = &prev->red_drawable->u.copy.src_area;
> > - return __red_is_next_stream_frame(worker, candidate, prev_src
> > ->right - prev_src->left,
> > - prev_src->bottom - prev_src
> > ->top,
> > - &prev->red_drawable->bbox,
> > prev->creation_time,
> > - prev->stream,
> > - FALSE);
> > -}
> > -
> > -static inline void pre_stream_item_swap(RedWorker *worker, Stream
> > *stream, Drawable *new_frame)
> > +static void before_reattach_stream(DisplayChannel *display,
> > + Stream *stream, Drawable
> > *new_frame)
> > {
> > DrawablePipeItem *dpi;
> > DisplayChannelClient *dcc;
> > @@ -2259,9 +2195,9 @@ static inline void
> > pre_stream_item_swap(RedWorker *worker, Stream *stream, Drawa
> > StreamAgent *agent;
> > RingItem *ring_item, *next;
> >
> > - spice_assert(stream->current);
> > + spice_return_if_fail(stream->current);
> >
> > - if (!display_is_connected(worker)) {
> > + if (!red_channel_is_connected(RED_CHANNEL(display))) {
> > return;
> > }
> >
> > @@ -2270,7 +2206,7 @@ static inline void
> > pre_stream_item_swap(RedWorker *worker, Stream *stream, Drawa
> > return;
> > }
> >
> > - index = get_stream_id(worker, stream);
> > + index = get_stream_id(display, stream);
> > DRAWABLE_FOREACH_DPI_SAFE(stream->current, ring_item, next, dpi)
> > {
> > dcc = dpi->dcc;
> > agent = &dcc->stream_agents[index];
> > @@ -2293,7 +2229,7 @@ static inline void
> > pre_stream_item_swap(RedWorker *worker, Stream *stream, Drawa
> > }
> >
> >
> > - FOREACH_DCC(worker->display_channel, ring_item, next, dcc) {
> > + FOREACH_DCC(display, ring_item, next, dcc) {
> > double drop_factor;
> >
> > agent = &dcc->stream_agents[index];
> > @@ -2324,12 +2260,13 @@ static inline void
> > pre_stream_item_swap(RedWorker *worker, Stream *stream, Drawa
> > }
> > }
> >
> > -static inline void red_update_copy_graduality(RedWorker* worker,
> > Drawable *drawable)
> > +static void update_copy_graduality(Drawable *drawable)
> > {
> > SpiceBitmap *bitmap;
> > - spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
> > + spice_return_if_fail(drawable->red_drawable->type ==
> > QXL_DRAW_COPY);
> >
> > - if (worker->streaming_video != SPICE_STREAM_VIDEO_FILTER) {
> > + /* TODO: global property -> per dc/dcc */
> > + if (streaming_video != SPICE_STREAM_VIDEO_FILTER) {
> > drawable->copy_bitmap_graduality = BITMAP_GRADUAL_INVALID;
> > return;
> > }
> > @@ -2348,7 +2285,7 @@ static inline void
> > red_update_copy_graduality(RedWorker* worker, Drawable *drawa
> > }
> > }
> >
> > -static inline int red_is_stream_start(Drawable *drawable)
> > +static int is_stream_start(Drawable *drawable)
> > {
> > return ((drawable->frames_count >=
> > RED_STREAM_FRAMES_START_CONDITION) &&
> > (drawable->gradual_frames_count >=
> > @@ -2356,13 +2293,13 @@ static inline int
> > red_is_stream_start(Drawable *drawable)
> > }
> >
> > // returns whether a stream was created
> > -static int red_stream_add_frame(RedWorker *worker,
> > - Drawable *frame_drawable,
> > - int frames_count,
> > - int gradual_frames_count,
> > - int last_gradual_frame)
> > +static int display_channel_stream_add_frame(DisplayChannel *display,
> > + Drawable
> > *frame_drawable,
> > + int frames_count,
> > + int
> > gradual_frames_count,
> > + int last_gradual_frame)
> > {
> > - red_update_copy_graduality(worker, frame_drawable);
> > + update_copy_graduality(frame_drawable);
> > frame_drawable->frames_count = frames_count + 1;
> > frame_drawable->gradual_frames_count = gradual_frames_count;
> >
> > @@ -2380,45 +2317,52 @@ static int red_stream_add_frame(RedWorker
> > *worker,
> > frame_drawable->last_gradual_frame = last_gradual_frame;
> > }
> >
> > - if (red_is_stream_start(frame_drawable)) {
> > - red_create_stream(worker, frame_drawable);
> > + if (is_stream_start(frame_drawable)) {
> > + display_channel_create_stream(display, frame_drawable);
> > return TRUE;
> > }
> > return FALSE;
> > }
> >
> > -static inline void red_stream_maintenance(RedWorker *worker,
> > Drawable *candidate, Drawable *prev)
> > +static void display_channel_stream_maintenance(DisplayChannel
> > *display,
> > + Drawable *candidate,
> > Drawable *prev)
> > {
> > - Stream *stream;
> > + int is_next_frame;
> >
> > if (candidate->stream) {
> > return;
> > }
> >
> > - if ((stream = prev->stream)) {
> > - int is_next_frame = __red_is_next_stream_frame(worker,
> > - candidate,
> > - stream
> > ->width,
> > - stream
> > ->height,
> > - &stream
> > ->dest_area,
> > - stream
> > ->last_time,
> > - stream,
> > - TRUE);
> > + if (prev->stream) {
> > + Stream *stream = prev->stream;
> > +
> > + is_next_frame = is_next_stream_frame(display, candidate,
> > + stream->width, stream
> > ->height,
> > + &stream->dest_area,
> > stream->last_time,
> > + stream, TRUE);
> > if (is_next_frame != STREAM_FRAME_NONE) {
> > - pre_stream_item_swap(worker, stream, candidate);
> > - red_detach_stream(worker, stream, FALSE);
> > + before_reattach_stream(display, stream, candidate);
> > + detach_stream(display, stream, FALSE);
> > prev->streamable = FALSE; //prevent item trace
> > - red_attach_stream(worker, candidate, stream);
> > + attach_stream(display, candidate, stream);
> > if (is_next_frame == STREAM_FRAME_CONTAINER) {
> > candidate->sized_stream = stream;
> > }
> > }
> > - } else {
> > - if (red_is_next_stream_frame(worker, candidate, prev) !=
> > STREAM_FRAME_NONE) {
> > - red_stream_add_frame(worker, candidate,
> > - prev->frames_count,
> > - prev->gradual_frames_count,
> > - prev->last_gradual_frame);
> > + } else if (candidate->streamable) {
> > + SpiceRect* prev_src = &prev->red_drawable->u.copy.src_area;
> > +
> > + is_next_frame =
> > + is_next_stream_frame(display, candidate, prev_src->right
> > - prev_src->left,
> > + prev_src->bottom - prev_src->top,
> > + &prev->red_drawable->bbox, prev
> > ->creation_time,
> > + prev->stream,
> > + FALSE);
> > + if (is_next_frame != STREAM_FRAME_NONE) {
> > + display_channel_stream_add_frame(display, candidate,
> > + prev->frames_count,
> > + prev
> > ->gradual_frames_count,
> > + prev
> > ->last_gradual_frame);
> > }
> > }
> > }
> > @@ -2456,7 +2400,7 @@ static inline int
> > red_current_add_equal(RedWorker *worker, DrawItem *item, TreeI
> > if (item->effect == QXL_EFFECT_OPAQUE) {
> > int add_after = !!other_drawable->stream &&
> >
> > is_drawable_independent_from_surfaces(drawable);
> > - red_stream_maintenance(worker, drawable, other_drawable);
> > + display_channel_stream_maintenance(worker->display_channel,
> > drawable, other_drawable);
> > __current_add_drawable(worker, drawable, &other
> > ->siblings_link);
> > other_drawable->refs++;
> > current_remove_drawable(worker, other_drawable);
> > @@ -2530,56 +2474,55 @@ static inline int
> > red_current_add_equal(RedWorker *worker, DrawItem *item, TreeI
> > return FALSE;
> > }
> >
> > -static inline void red_use_stream_trace(RedWorker *worker, Drawable
> > *drawable)
> > +#define FOREACH_STREAMS(display, item) \
> > + for (item = ring_get_head(&(display)->streams); \
> > + item != NULL; \
> > + item = ring_next(&(display)->streams, item))
> > +
> > +static void red_use_stream_trace(DisplayChannel *display, Drawable
> > *drawable)
> > {
> > ItemTrace *trace;
> > ItemTrace *trace_end;
> > - Ring *ring;
> > RingItem *item;
> >
> > if (drawable->stream || !drawable->streamable || drawable
> > ->frames_count) {
> > return;
> > }
> >
> > -
> > - ring = &worker->streams;
> > - item = ring_get_head(ring);
> > -
> > - while (item) {
> > + FOREACH_STREAMS(display, item) {
> > Stream *stream = SPICE_CONTAINEROF(item, Stream, link);
> > - int is_next_frame = __red_is_next_stream_frame(worker,
> > - drawable,
> > - stream
> > ->width,
> > - stream
> > ->height,
> > - &stream
> > ->dest_area,
> > - stream
> > ->last_time,
> > - stream,
> > - TRUE);
> > + int is_next_frame = is_next_stream_frame(display,
> > + drawable,
> > + stream->width,
> > + stream->height,
> > + &stream->dest_area,
> > + stream->last_time,
> > + stream,
> > + TRUE);
> > if (is_next_frame != STREAM_FRAME_NONE) {
> > if (stream->current) {
> > stream->current->streamable = FALSE; //prevent item
> > trace
> > - pre_stream_item_swap(worker, stream, drawable);
> > - red_detach_stream(worker, stream, FALSE);
> > + before_reattach_stream(display, stream, drawable);
> > + detach_stream(display, stream, FALSE);
> > }
> > - red_attach_stream(worker, drawable, stream);
> > + attach_stream(display, drawable, stream);
> > if (is_next_frame == STREAM_FRAME_CONTAINER) {
> > drawable->sized_stream = stream;
> > }
> > return;
> > }
> > - item = ring_next(ring, item);
> > }
> >
> > - trace = worker->items_trace;
> > + trace = display->items_trace;
> > trace_end = trace + NUM_TRACE_ITEMS;
> > for (; trace < trace_end; trace++) {
> > - if (__red_is_next_stream_frame(worker, drawable, trace
> > ->width, trace->height,
> > + if (is_next_stream_frame(display, drawable, trace->width,
> > trace->height,
> > &trace->dest_area, trace
> > ->time, NULL, FALSE) !=
> > STREAM_FRAME_NONE) {
> > - if (red_stream_add_frame(worker, drawable,
> > - trace->frames_count,
> > - trace->gradual_frames_count,
> > - trace->last_gradual_frame)) {
> > + if (display_channel_stream_add_frame(display, drawable,
> > + trace
> > ->frames_count,
> > + trace
> > ->gradual_frames_count,
> > + trace
> > ->last_gradual_frame)) {
> > return;
> > }
> > }
> > @@ -2681,8 +2624,8 @@ static inline int red_current_add(RedWorker
> > *worker, Ring *ring, Drawable *drawa
> > if (item->effect == QXL_EFFECT_OPAQUE) {
> > region_or(&exclude_rgn, &item->base.rgn);
> > exclude_region(worker, ring, exclude_base, &exclude_rgn,
> > NULL, drawable);
> > - red_use_stream_trace(worker, drawable);
> > - red_streams_update_visible_region(worker, drawable);
> > + red_use_stream_trace(worker->display_channel, drawable);
> > + streams_update_visible_region(worker->display_channel,
> > drawable);
> > /*
> > * Performing the insertion after exclude_region for
> > * safety (todo: Not sure if exclude_region can affect the
> > drawable
> > @@ -2696,8 +2639,8 @@ static inline int red_current_add(RedWorker
> > *worker, Ring *ring, Drawable *drawa
> > * before calling red_detach_streams_behind
> > */
> > __current_add_drawable(worker, drawable, ring);
> > - if (is_primary_surface(worker, drawable->surface_id)) {
> > - red_detach_streams_behind(worker, &drawable
> > ->tree_item.base.rgn, drawable);
> > + if (is_primary_surface(worker->display_channel, drawable
> > ->surface_id)) {
> > + detach_streams_behind(worker->display_channel, &drawable
> > ->tree_item.base.rgn, drawable);
> > }
> > }
> > region_destroy(&exclude_rgn);
> > @@ -2716,6 +2659,7 @@ static void add_clip_rects(QRegion *rgn,
> > SpiceClipRects *data)
> >
> > static inline int red_current_add_with_shadow(RedWorker *worker,
> > Ring *ring, Drawable *item)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > #ifdef RED_WORKER_STAT
> > stat_time_t start_time = stat_now(worker);
> > ++worker->add_with_shadow_count;
> > @@ -2736,8 +2680,8 @@ static inline int
> > red_current_add_with_shadow(RedWorker *worker, Ring *ring, Dra
> > // for now putting them on root.
> >
> > // only primary surface streams are supported
> > - if (is_primary_surface(worker, item->surface_id)) {
> > - red_detach_streams_behind(worker, &shadow->base.rgn, NULL);
> > + if (is_primary_surface(display, item->surface_id)) {
> > + detach_streams_behind(display, &shadow->base.rgn, NULL);
> > }
> >
> > ring_add(ring, &shadow->base.siblings_link);
> > @@ -2747,10 +2691,10 @@ static inline int
> > red_current_add_with_shadow(RedWorker *worker, Ring *ring, Dra
> > region_clone(&exclude_rgn, &item->tree_item.base.rgn);
> > exclude_region(worker, ring, &shadow->base.siblings_link,
> > &exclude_rgn, NULL, NULL);
> > region_destroy(&exclude_rgn);
> > - red_streams_update_visible_region(worker, item);
> > + streams_update_visible_region(display, item);
> > } else {
> > - if (is_primary_surface(worker, item->surface_id)) {
> > - red_detach_streams_behind(worker, &item
> > ->tree_item.base.rgn, item);
> > + if (is_primary_surface(display, item->surface_id)) {
> > + detach_streams_behind(display, &item
> > ->tree_item.base.rgn, item);
> > }
> > }
> > stat_add(&worker->add_stat, start_time);
> > @@ -2762,22 +2706,22 @@ static inline int has_shadow(RedDrawable
> > *drawable)
> > return drawable->type == QXL_COPY_BITS;
> > }
> >
> > -static inline void red_update_streamable(RedWorker *worker, Drawable
> > *drawable,
> > - RedDrawable *red_drawable)
> > +static void drawable_update_streamable(DisplayChannel *display,
> > Drawable *drawable)
> > {
> > + RedDrawable *red_drawable = drawable->red_drawable;
> > SpiceImage *image;
> >
> > - if (worker->streaming_video == SPICE_STREAM_VIDEO_OFF) {
> > + if (display->stream_video == SPICE_STREAM_VIDEO_OFF) {
> > return;
> > }
> >
> > - if (!is_primary_surface(worker, drawable->surface_id)) {
> > + if (!is_primary_surface(display, drawable->surface_id)) {
> > return;
> > }
> >
> > if (drawable->tree_item.effect != QXL_EFFECT_OPAQUE ||
> > - red_drawable->type !=
> > QXL_DRAW_COPY ||
> > - red_drawable
> > ->u.copy.rop_descriptor != SPICE_ROPD_OP_PUT) {
> > + red_drawable->type != QXL_DRAW_COPY ||
> > + red_drawable->u.copy.rop_descriptor != SPICE_ROPD_OP_PUT) {
> > return;
> > }
> >
> > @@ -2787,7 +2731,7 @@ static inline void
> > red_update_streamable(RedWorker *worker, Drawable *drawable,
> > return;
> > }
> >
> > - if (worker->streaming_video == SPICE_STREAM_VIDEO_FILTER) {
> > + if (display->stream_video == SPICE_STREAM_VIDEO_FILTER) {
> > SpiceRect* rect;
> > int size;
> >
> > @@ -2831,6 +2775,7 @@ static void red_print_stats(RedWorker *worker)
> >
> > static int red_add_drawable(RedWorker *worker, Drawable *drawable)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > int ret = FALSE, surface_id = drawable->surface_id;
> > RedDrawable *red_drawable = drawable->red_drawable;
> > Ring *ring = &worker->surfaces[surface_id].current;
> > @@ -2838,7 +2783,7 @@ static int red_add_drawable(RedWorker *worker,
> > Drawable *drawable)
> > if (has_shadow(red_drawable)) {
> > ret = red_current_add_with_shadow(worker, ring, drawable);
> > } else {
> > - red_update_streamable(worker, drawable, red_drawable);
> > + drawable_update_streamable(display, drawable);
> > ret = red_current_add(worker, ring, drawable);
> > }
> >
> > @@ -2891,6 +2836,7 @@ static int rgb32_data_has_alpha(int width, int
> > height, size_t stride,
> >
> > static inline int red_handle_self_bitmap(RedWorker *worker, Drawable
> > *drawable)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > SpiceImage *image;
> > int32_t width;
> > int32_t height;
> > @@ -2936,7 +2882,7 @@ static inline int
> > red_handle_self_bitmap(RedWorker *worker, Drawable *drawable)
> >
> > /* For 32bit non-primary surfaces we need to keep any non-zero
> > high bytes as the surface may be used as source to an
> > alpha_blend */
> > - if (!is_primary_surface(worker, drawable->surface_id) &&
> > + if (!is_primary_surface(display, drawable->surface_id) &&
> > image->u.bitmap.format == SPICE_BITMAP_FMT_32BIT &&
> > rgb32_data_has_alpha(width, height, dest_stride, dest,
> > &all_set)) {
> > if (all_set) {
> > @@ -3054,6 +3000,7 @@ static inline void
> > add_to_surface_dependency(RedWorker *worker, int depend_on_su
> >
> > static inline int red_handle_surfaces_dependencies(RedWorker
> > *worker, Drawable *drawable)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > int x;
> >
> > for (x = 0; x < 3; ++x) {
> > @@ -3067,7 +3014,7 @@ static inline int
> > red_handle_surfaces_dependencies(RedWorker *worker, Drawable *
> > QRegion depend_region;
> > region_init(&depend_region);
> > region_add(&depend_region, &drawable->red_drawable
> > ->surfaces_rects[x]);
> > - red_detach_streams_behind(worker, &depend_region,
> > NULL);
> > + detach_streams_behind(display, &depend_region,
> > NULL);
> > }
> > }
> > }
> > @@ -3747,9 +3694,9 @@ static void red_current_flush(RedWorker
> > *worker, int surface_id)
> > static ImageItem *red_add_surface_area_image(DisplayChannelClient
> > *dcc, int surface_id,
> > SpiceRect *area,
> > PipeItem *pos, int can_lossy)
> > {
> > - DisplayChannel *display_channel = DCC_TO_DC(dcc);
> > - RedWorker *worker = display_channel->common.worker;
> > - RedChannel *channel = RED_CHANNEL(display_channel);
> > + DisplayChannel *display = DCC_TO_DC(dcc);
> > + RedChannel *channel = RED_CHANNEL(display);
> > + RedWorker *worker = DCC_TO_WORKER(dcc);
> > RedSurface *surface = &worker->surfaces[surface_id];
> > SpiceCanvas *canvas = surface->context.canvas;
> > ImageItem *item;
> > @@ -3787,7 +3734,7 @@ static ImageItem
> > *red_add_surface_area_image(DisplayChannelClient *dcc, int surf
> >
> > /* For 32bit non-primary surfaces we need to keep any non-zero
> > high bytes as the surface may be used as source to an
> > alpha_blend */
> > - if (!is_primary_surface(worker, surface_id) &&
> > + if (!is_primary_surface(display, surface_id) &&
> > item->image_format == SPICE_BITMAP_FMT_32BIT &&
> > rgb32_data_has_alpha(item->width, item->height, item
> > ->stride, item->data, &all_set)) {
> > if (all_set) {
> > @@ -6970,10 +6917,9 @@ static inline int
> > red_marshall_stream_data(RedChannelClient *rcc,
> > SpiceMarshaller *base_marshaller, Drawable
> > *drawable)
> > {
> > DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> > - DisplayChannel *display_channel = SPICE_CONTAINEROF(rcc
> > ->channel, DisplayChannel, common.base);
> > + DisplayChannel *display = DCC_TO_DC(dcc);
> > Stream *stream = drawable->stream;
> > SpiceImage *image;
> > - RedWorker *worker = DCC_TO_WORKER(dcc);
> > uint32_t frame_mm_time;
> > int n;
> > int width, height;
> > @@ -6985,7 +6931,6 @@ static inline int
> > red_marshall_stream_data(RedChannelClient *rcc,
> > }
> > spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
> >
> > - worker = display_channel->common.worker;
> > image = drawable->red_drawable->u.copy.src_bitmap;
> >
> > if (image->descriptor.type != SPICE_IMAGE_TYPE_BITMAP) {
> > @@ -7006,7 +6951,7 @@ static inline int
> > red_marshall_stream_data(RedChannelClient *rcc,
> > height = stream->height;
> > }
> >
> > - StreamAgent *agent = &dcc->stream_agents[get_stream_id(worker,
> > stream)];
> > + StreamAgent *agent = &dcc->stream_agents[get_stream_id(display,
> > stream)];
> > uint64_t time_now = red_get_monotonic_time();
> > size_t outbuf_size;
> >
> > @@ -7054,7 +6999,7 @@ static inline int
> > red_marshall_stream_data(RedChannelClient *rcc,
> >
> > red_channel_client_init_send_data(rcc,
> > SPICE_MSG_DISPLAY_STREAM_DATA, NULL);
> >
> > - stream_data.base.id = get_stream_id(worker, stream);
> > + stream_data.base.id = get_stream_id(display, stream);
> > stream_data.base.multi_media_time = frame_mm_time;
> > stream_data.data_size = n;
> >
> > @@ -7064,7 +7009,7 @@ static inline int
> > red_marshall_stream_data(RedChannelClient *rcc,
> >
> > red_channel_client_init_send_data(rcc,
> > SPICE_MSG_DISPLAY_STREAM_DATA_SIZED, NULL);
> >
> > - stream_data.base.id = get_stream_id(worker, stream);
> > + stream_data.base.id = get_stream_id(display, stream);
> > stream_data.base.multi_media_time = frame_mm_time;
> > stream_data.data_size = n;
> > stream_data.width = width;
> > @@ -7436,7 +7381,7 @@ static void
> > red_display_marshall_stream_start(RedChannelClient *rcc,
> > SpiceClipRects clip_rects;
> >
> > stream_create.surface_id = 0;
> > - stream_create.id = get_stream_id(DCC_TO_WORKER(dcc), stream);
> > + stream_create.id = get_stream_id(DCC_TO_DC(dcc), stream);
> > stream_create.flags = stream->top_down ?
> > SPICE_STREAM_FLAGS_TOP_DOWN : 0;
> > stream_create.codec_type = SPICE_VIDEO_CODEC_TYPE_MJPEG;
> >
> > @@ -7472,7 +7417,7 @@ static void
> > red_display_marshall_stream_clip(RedChannelClient *rcc,
> > red_channel_client_init_send_data(rcc,
> > SPICE_MSG_DISPLAY_STREAM_CLIP, &item->base);
> > SpiceMsgDisplayStreamClip stream_clip;
> >
> > - stream_clip.id = get_stream_id(DCC_TO_WORKER(dcc), agent
> > ->stream);
> > + stream_clip.id = get_stream_id(DCC_TO_DC(dcc), agent->stream);
> > stream_clip.clip.type = item->clip_type;
> > stream_clip.clip.rects = item->rects;
> >
> > @@ -7486,7 +7431,7 @@ static void
> > red_display_marshall_stream_end(RedChannelClient *rcc,
> > SpiceMsgDisplayStreamDestroy destroy;
> >
> > red_channel_client_init_send_data(rcc,
> > SPICE_MSG_DISPLAY_STREAM_DESTROY, NULL);
> > - destroy.id = get_stream_id(DCC_TO_WORKER(dcc), agent->stream);
> > + destroy.id = get_stream_id(DCC_TO_DC(dcc), agent->stream);
> > red_display_stream_agent_stop(dcc, agent);
> > spice_marshall_msg_display_stream_destroy(base_marshaller,
> > &destroy);
> > }
> > @@ -7721,20 +7666,20 @@ void
> > red_disconnect_all_display_TODO_remove_me(RedChannel *channel)
> > red_channel_apply_clients(channel,
> > red_channel_client_disconnect);
> > }
> >
> > -static void red_destroy_streams(RedWorker *worker)
> > +static void detach_and_stop_streams(DisplayChannel *display)
> > {
> > RingItem *stream_item;
> >
> > spice_debug(NULL);
> > - while ((stream_item = ring_get_head(&worker->streams))) {
> > + while ((stream_item = ring_get_head(&display->streams))) {
> > Stream *stream = SPICE_CONTAINEROF(stream_item, Stream,
> > link);
> >
> > - red_detach_stream_gracefully(worker, stream, NULL);
> > - red_stop_stream(worker, stream);
> > + detach_stream_gracefully(display, stream, NULL);
> > + stop_stream(display, stream);
> > }
> > }
> >
> > -static void red_migrate_display(RedWorker *worker, RedChannelClient
> > *rcc)
> > +static void red_migrate_display(DisplayChannel *display,
> > RedChannelClient *rcc)
> > {
> > /* We need to stop the streams, and to send upgrade_items to the
> > client.
> > * Otherwise, (1) the client might display lossy regions that we
> > don't track
> > @@ -7743,10 +7688,10 @@ static void red_migrate_display(RedWorker
> > *worker, RedChannelClient *rcc)
> > * being sent to the client after MSG_MIGRATE and before
> > MSG_MIGRATE_DATA (e.g.,
> > * STREAM_CLIP, STREAM_DESTROY, DRAW_COPY)
> > * No message besides MSG_MIGRATE_DATA should be sent after
> > MSG_MIGRATE.
> > - * Notice that red_destroy_streams won't lead to any dev ram
> > changes, since
> > + * Notice that detach_and_stop_streams won't lead to any dev ram
> > changes, since
> > * handle_dev_stop already took care of releasing all the dev
> > ram resources.
> > */
> > - red_destroy_streams(worker);
> > + detach_and_stop_streams(display);
> > if (red_channel_client_is_connected(rcc)) {
> > red_channel_client_default_migrate(rcc);
> > }
> > @@ -7868,7 +7813,7 @@ static inline void
> > red_create_surface_item(DisplayChannelClient *dcc, int surfac
> > RedSurface *surface;
> > SurfaceCreateItem *create;
> > RedWorker *worker = dcc ? DCC_TO_WORKER(dcc) : NULL;
> > - uint32_t flags = is_primary_surface(worker, surface_id) ?
> > SPICE_SURFACE_FLAGS_PRIMARY : 0;
> > + uint32_t flags = is_primary_surface(DCC_TO_DC(dcc), surface_id)
> > ? SPICE_SURFACE_FLAGS_PRIMARY : 0;
> >
> > /* don't send redundant create surface commands to client */
> > if (!dcc || worker->display_channel
> > ->common.during_target_migrate ||
> > @@ -8747,17 +8692,17 @@ static void
> > display_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item
> > static void
> > display_channel_client_release_item_after_push(DisplayChannelClient
> > *dcc,
> > PipeItem
> > *item)
> > {
> > - RedWorker *worker = DCC_TO_WORKER(dcc);
> > + DisplayChannel *display = DCC_TO_DC(dcc);
> >
> > switch (item->type) {
> > case PIPE_ITEM_TYPE_DRAW:
> > drawable_pipe_item_unref(SPICE_CONTAINEROF(item,
> > DrawablePipeItem, dpi_pipe_item));
> > break;
> > case PIPE_ITEM_TYPE_STREAM_CLIP:
> > - red_display_release_stream_clip(worker, (StreamClipItem
> > *)item);
> > + display_stream_clip_unref(display, (StreamClipItem *)item);
> > break;
> > case PIPE_ITEM_TYPE_UPGRADE:
> > - release_upgrade_item(worker, (UpgradeItem *)item);
> > + release_upgrade_item(DCC_TO_WORKER(dcc), (UpgradeItem
> > *)item);
> > break;
> > case PIPE_ITEM_TYPE_IMAGE:
> > release_image_item((ImageItem *)item);
> > @@ -8782,7 +8727,7 @@ static void
> > display_channel_client_release_item_after_push(DisplayChannelClient
> > static void
> > display_channel_client_release_item_before_push(DisplayChannelClient
> > *dcc,
> > PipeItem
> > *item)
> > {
> > - RedWorker *worker = DCC_TO_WORKER(dcc);
> > + DisplayChannel *display = DCC_TO_DC(dcc);
> >
> > switch (item->type) {
> > case PIPE_ITEM_TYPE_DRAW: {
> > @@ -8793,19 +8738,19 @@ static void
> > display_channel_client_release_item_before_push(DisplayChannelClient
> > }
> > case PIPE_ITEM_TYPE_STREAM_CREATE: {
> > StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent,
> > create_item);
> > - red_display_release_stream(worker, agent);
> > + display_stream_agent_unref(display, agent);
> > break;
> > }
> > case PIPE_ITEM_TYPE_STREAM_CLIP:
> > - red_display_release_stream_clip(worker, (StreamClipItem
> > *)item);
> > + display_stream_clip_unref(display, (StreamClipItem *)item);
> > break;
> > case PIPE_ITEM_TYPE_STREAM_DESTROY: {
> > StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent,
> > destroy_item);
> > - red_display_release_stream(worker, agent);
> > + display_stream_agent_unref(display, agent);
> > break;
> > }
> > case PIPE_ITEM_TYPE_UPGRADE:
> > - release_upgrade_item(worker, (UpgradeItem *)item);
> > + release_upgrade_item(DCC_TO_WORKER(dcc), (UpgradeItem
> > *)item);
> > break;
> > case PIPE_ITEM_TYPE_IMAGE:
> > release_image_item((ImageItem *)item);
> > @@ -8856,16 +8801,16 @@ static void
> > display_channel_release_item(RedChannelClient *rcc, PipeItem *item,
> > }
> > }
> >
> > -static void red_init_streams(RedWorker *worker)
> > +static void init_streams(DisplayChannel *display)
> > {
> > int i;
> >
> > - ring_init(&worker->streams);
> > - worker->free_streams = NULL;
> > + ring_init(&display->streams);
> > + display->free_streams = NULL;
> > for (i = 0; i < NUM_STREAMS; i++) {
> > - Stream *stream = &worker->streams_buf[i];
> > + Stream *stream = &display->streams_buf[i];
> > ring_item_init(&stream->link);
> > - red_free_stream(worker, stream);
> > + display_stream_free(display, stream);
> > }
> > }
> >
> > @@ -8885,7 +8830,7 @@ static void display_channel_create(RedWorker
> > *worker, int migrate)
> > spice_return_if_fail(num_renderers > 0);
> >
> > spice_info("create display channel");
> > - if (!(worker->display_channel = (DisplayChannel
> > *)red_worker_new_channel(
> > + if (!(display_channel = (DisplayChannel
> > *)red_worker_new_channel(
> > worker, sizeof(*display_channel), "display_channel",
> > SPICE_CHANNEL_DISPLAY,
> > SPICE_MIGRATE_NEED_FLUSH |
> > SPICE_MIGRATE_NEED_DATA_TRANSFER,
> > @@ -8893,7 +8838,7 @@ static void display_channel_create(RedWorker
> > *worker, int migrate)
> > spice_warning("failed to create display channel");
> > return;
> > }
> > - display_channel = worker->display_channel;
> > + worker->display_channel = display_channel;
> > #ifdef RED_STATISTICS
> > RedChannel *channel = RED_CHANNEL(display_channel);
> > display_channel->cache_hits_counter = stat_add_counter(channel
> > ->stat,
> > @@ -8914,6 +8859,7 @@ static void display_channel_create(RedWorker
> > *worker, int migrate)
> > display_channel->num_renderers = num_renderers;
> > memcpy(display_channel->renderers, renderers,
> > sizeof(display_channel->renderers));
> > display_channel->renderer = RED_RENDERER_INVALID;
> > + init_streams(display_channel);
> > image_cache_init(&display_channel->image_cache);
> > }
> >
> > @@ -9189,6 +9135,7 @@ static void
> > handle_dev_destroy_surface_wait(void *opaque, void *payload)
> > /* TODO: split me*/
> > static inline void dev_destroy_surfaces(RedWorker *worker)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > int i;
> >
> > spice_debug(NULL);
> > @@ -9203,7 +9150,7 @@ static inline void
> > dev_destroy_surfaces(RedWorker *worker)
> > spice_assert(!worker->surfaces[i].context.canvas);
> > }
> > }
> > - spice_assert(ring_is_empty(&worker->streams));
> > + spice_assert(ring_is_empty(&display->streams));
> >
> > if (display_is_connected(worker)) {
> > red_channel_pipes_add_type(RED_CHANNEL(worker
> > ->display_channel),
> > @@ -9317,6 +9264,8 @@ static void
> > handle_dev_create_primary_surface(void *opaque, void *payload)
> >
> > static void dev_destroy_primary_surface(RedWorker *worker, uint32_t
> > surface_id)
> > {
> > + DisplayChannel *display = worker->display_channel;
> > +
> > VALIDATE_SURFACE_RET(worker, surface_id);
> > spice_warn_if(surface_id != 0);
> >
> > @@ -9329,7 +9278,7 @@ static void
> > dev_destroy_primary_surface(RedWorker *worker, uint32_t surface_id)
> > flush_all_qxl_commands(worker);
> > dev_destroy_surface_wait(worker, 0);
> > red_surface_unref(worker, 0);
> > - spice_assert(ring_is_empty(&worker->streams));
> > + spice_warn_if_fail(ring_is_empty(&display->streams));
> >
> > spice_assert(!worker->surfaces[surface_id].context.canvas);
> >
> > @@ -9570,7 +9519,7 @@ static void handle_dev_display_migrate(void
> > *opaque, void *payload)
> > RedChannelClient *rcc = msg->rcc;
> > spice_info("migrate display client");
> > spice_assert(rcc);
> > - red_migrate_display(worker, rcc);
> > + red_migrate_display(worker->display_channel, rcc);
> > }
> >
> > static inline uint32_t qxl_monitors_config_size(uint32_t heads)
> > @@ -9701,21 +9650,7 @@ static void
> > handle_dev_set_streaming_video(void *opaque, void *payload)
> > RedWorkerMessageSetStreamingVideo *msg = payload;
> > RedWorker *worker = opaque;
> >
> > - worker->streaming_video = msg->streaming_video;
> > - spice_assert(worker->streaming_video !=
> > SPICE_STREAM_VIDEO_INVALID);
> > - switch(worker->streaming_video) {
> > - case SPICE_STREAM_VIDEO_ALL:
> > - spice_info("sv all");
> > - break;
> > - case SPICE_STREAM_VIDEO_FILTER:
> > - spice_info("sv filter");
> > - break;
> > - case SPICE_STREAM_VIDEO_OFF:
> > - spice_info("sv off");
> > - break;
> > - default:
> > - spice_warning("sv invalid");
> > - }
> > + display_channel_set_stream_video(worker->display_channel, msg
> > ->streaming_video);
> > }
> >
> > static void handle_dev_set_mouse_mode(void *opaque, void *payload)
> > @@ -10048,12 +9983,10 @@ RedWorker* red_worker_new(QXLInstance *qxl,
> > RedDispatcher *red_dispatcher)
> > worker->image_compression = image_compression;
> > worker->jpeg_state = jpeg_state;
> > worker->zlib_glz_state = zlib_glz_state;
> > - worker->streaming_video = streaming_video;
> > worker->driver_cap_monitors_config = 0;
> > ring_init(&worker->current_list);
> > image_surface_init(worker);
> > drawables_init(worker);
> > - red_init_streams(worker);
> > stat_init(&worker->add_stat, add_stat_name);
> > stat_init(&worker->exclude_stat, exclude_stat_name);
> > stat_init(&worker->__exclude_stat, __exclude_stat_name);
> > @@ -10132,10 +10065,10 @@ SPICE_GNUC_NORETURN static void
> > *red_worker_main(void *arg)
> >
> > timeout = spice_timer_queue_get_timeout_ms();
> > worker->event_timeout = MIN(timeout, worker->event_timeout);
> > - timeout = red_get_streams_timout(worker);
> > + timeout = display_channel_get_streams_timeout(worker
> > ->display_channel);
> > worker->event_timeout = MIN(timeout, worker->event_timeout);
> > num_events = poll(worker->poll_fds, MAX_EVENT_SOURCES,
> > worker->event_timeout);
> > - red_handle_streams_timout(worker);
> > + display_channel_streams_timeout(worker->display_channel);
> > spice_timer_queue_cb();
> >
> > if (worker->display_channel) {
> > diff --git a/server/stream.c b/server/stream.c
> > index 4545963..7ef7876 100644
> > --- a/server/stream.c
> > +++ b/server/stream.c
> > @@ -32,8 +32,8 @@ void stream_agent_stats_print(StreamAgent *agent)
> > mjpeg_encoder_get_stats(agent->mjpeg_encoder,
> > &encoder_stats);
> > }
> >
> > - spice_debug("stream=%p dim=(%dx%d) #in-frames=%"PRIu64" #in-avg
> > -fps=%.2f #out-frames=%"PRIu64" "
> > - "out/in=%.2f #drops=%"PRIu64" (#pipe=%"PRIu64"
> > #fps=%"PRIu64") out-avg-fps=%.2f "
> > + spice_debug("stream=%p dim=(%dx%d) #in-frames=%lu #in-avg
> > -fps=%.2f #out-frames=%lu "
> > + "out/in=%.2f #drops=%lu (#pipe=%lu #fps=%lu) out-avg
> > -fps=%.2f "
> > "passed-mm-time(sec)=%.2f size-total(MB)=%.2f size
> > -per-sec(Mbps)=%.2f "
> > "size-per-frame(KBpf)=%.2f avg-quality=%.2f "
> > "start-bit-rate(Mbps)=%.2f end-bit-rate(Mbps)=%.2f",
> > diff --git a/server/stream.h b/server/stream.h
> > index 30b8624..f77fa96 100644
> > --- a/server/stream.h
> > +++ b/server/stream.h
> > @@ -106,6 +106,16 @@ typedef struct StreamClipItem {
> > StreamClipItem *stream_clip_item_new(DisplayChannelClient* dcc,
> > StreamAgent *agent);
> >
> > +typedef struct ItemTrace {
> > + red_time_t time;
> > + int frames_count;
> > + int gradual_frames_count;
> > + int last_gradual_frame;
> > + int width;
> > + int height;
> > + SpiceRect dest_area;
> > +} ItemTrace;
> > +
> > struct Stream {
> > uint8_t refs;
> > Drawable *current;
>
More information about the Spice-devel
mailing list